NOIP2015解题报告

最新推荐文章于 2019-10-05 19:08:32 发布

心若为城

最新推荐文章于 2019-10-05 19:08:32 发布

阅读量477

点赞数

分类专栏：学习整理

本文链接：https://blog.csdn.net/zxn0803/article/details/51477904

版权

学习整理专栏收录该内容

30 篇文章 0 订阅

订阅专栏

Day1.
当时的zxn很弱，弱到连dfs都调不明白就开始去NOIP。
现在他会了dfs，二分答案，求LCA，bfs，拓扑排序。
所以他回去填NOIP2015的题解坑。
T1.我现在依然不知道除了这种尾递归式的写法之外还有啥别的写法……
伪代码：

void dfs(int i,int j,int x)
{
    if(满足条件)w[i][j] = x;
    dfs(i',j',x + 1);
}

咳我好像现在明白了……
大概一个循环确实能搞出来……
T2.
求最小环，当时zxn心里确实也是这么想的。
由于他太弱了不会dfs，所以他并不知道怎么写。
题解：
dfs一遍，记一下时间戳。

void dfs(int x)
{
    vis[x] = 1;
    tid[x] = ++ tim;
    RepG(i,x)
        if(!vis[v])dfs(v);
        else ans = min(ans,tid[x] - tid[v] + 1);
    //大概是这样的吧
}

然后后来仔细一想，嗯我还是bfs吧。
次奥……？T掉了QAQ
嗯我们还是冷静一下，发现……
如果是bfs，需要拓扑排序，删掉没有用的那些点，只剩下环即可。

#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstring>
#define Rep(i,n) for(int i = 1; i <= n ; i ++)
#define RepG(i,x) for(int i = head[x] ;~ i ; i = edge[i].next)
#define Rep_d(i,n) for(int i = n ; i > 0 ; i --)
#define Rep_0(i,n) for(int i = 0 ; i < n ; i ++)
#define RD(i,x,n) for(int i = x; i <= n ; i ++)
#define CLR(a,b) memset(a,b,sizeof(a))
#define v edge[i].to
using namespace std;
int read(){
    char ch = getchar();
    while(ch < '0' || ch > '9')ch = getchar ();
    int x = 0;
    while(ch >= '0' && ch <= '9')x = 10 * x + ch - '0',ch = getchar ();
    return x;
}
int to[200005];
bool vis[200005],vis_now[200005];
int q[200005],tid[200005],tim = 0,ans = 1 << 30,end[200005];
int main()
{
    int n = read();
    Rep(i,n)
    {
        int a = read();
        to[i] = a;  
        end[to[i]] ++;
    }

    int h = 0,t = -1;   
    Rep(i,n)
        if(!end[i])vis[q[++ t] = i] = 1;
    while(h <= t){
        int x = q[h ++];
        end[to[x]] --;
        if(!end[to[x]])vis[q[++ t] = to[x]] = 1;
    }
    Rep(i,n){
        if(!vis[i]){
            h = 0,t = -1;
            vis[i] = 1;
            q[++ t] = i;
            tim = 0;
            tid[i] = 0;
            while(h <= t){
                int x = q[h ++];
                if(!vis_now[to[x]])vis_now[q[++ t] = to[x]] = 1,tid[to[x]] = ++ tim,vis[to[x]] = 1;
                else ans = min(ans,tim - tid[to[x]] + 1),h = t + 1;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

QAQ当时明明知道标算然而就是写不出来？
T3.
斗地主。
张地主出的一道水题。张地主亲口说道：“NOIP的一道水题。”
张地主这次CTSC还出了一道提交答案题。
“我们可以发现第8个点是个网格图。”
“第九个点是除了前几个调换了下顺序之外的网格图。”
“第十个点是挖掉了一些点的网格图。”
whx：“我要吐槽！怎么检验它是网格图呢？”
“我的暴力spfa怎么跑的这么慢呢……？”
TAT
题解：
暴力搜索即可。
我们考虑对于当前的手牌，先枚举顺子应该会优一点，因为这样方便加最优性剪枝。
我们考虑：
if(ans <= depth )return;
加这个剪枝就过了。

#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstring>
#define Rep(i,n) for(int i = 1; i <= n ; i ++)
#define RepG(i,x) for(int i = head[x] ;~ i ; i = edge[i].next)
#define Rep_d(i,n) for(int i = n ; i > 0 ; i --)
#define Rep_0(i,n) for(int i = 0 ; i < n ; i ++)
#define RD(i,x,n) for(int i = x; i <= n ; i ++)
#define CLR(a,b) memset(a,b,sizeof(a))
#define v edge[i].to
using namespace std;
int s[20];
int read(){
    char ch = getchar();
    while(ch < '0' || ch > '9')ch = getchar ();
    int x = 0;
    while(ch >= '0' && ch <= '9')x = 10 * x + ch - '0',ch = getchar ();
    return x;
}
int Cases,n,ans;
void dfs(int now){
    if(now >= ans)return;
    int a = 0,b = 0,c = 0;
    Rep_0(i,14)if(s[i] == 1)a ++;
    Rep_0(i,13)if(s[i] == 2)b ++;
    Rep_0(i,13)
        if(s[i] == 4){
            c ++;
            if(a >= 2)a -= 2;
            else if(b >= 2)b -= 2;
            else if(b >= 1)b --;
        }
    Rep_0(i,13)
        if(s[i] == 3){
            c ++;
            if(a >= 1)a --;
            else if(b >= 1)b --;
        }
    ans = min(ans,a + b + c + now);
    Rep_0(i,8){
        int j;
        for(j = i ; j <= 11 ; j ++){
            s[j] --;
            if(s[j] < 0)break;
            if(j - i >= 4)dfs(now + 1);
        }
        if(j == 12)j --;
        while(j >= i)s[j --] ++;
    }
    Rep_0(i,10){
        int j;
        for(j = i; j <= 11; j ++){
            s[j] -= 2;
            if(s[j] < 0)break;
            if(j - i >= 2)dfs(now + 1);
        }
        if(j == 12)j --;
        while(j >= i)s[j --] += 2;
    }
    Rep_0(i,11){
        int j;
        for(j = i; j <= 11; j ++){
            s[j] -= 3;
            if(s[j] < 0)break;
            if(j - i > 0)dfs(now + 1);
        }
        if(j == 12)j --;
        while(j >= i)s[j --] += 3;
    }
}
int main()
{
    Cases = read(),n = read();
    while(Cases --){
        CLR(s,0);
        ans = 10005;
        Rep(i,n){
            int c = read(),col = read();
            if(c < 3 && c)s[10 + c] ++;
            else if(c >= 3)s[c - 3] ++ ;
            else s[13] ++;
        }
        dfs(0);
        if(s[13] == 2)ans ++;
        printf("%d\n",ans);
    }
    return 0;
}

当时NOIP的时候，zxn表示自己：
“这个可能是某种神奇的搜索，估计写不出来。”
mdzz。
Day2.
zxn:”day1好像挺水的，虽然我不会做，但是算法还是都看出来的。day2应该很友善.”
T1.
跳石头。
zxn:”什么叫二分答案？？？”
题解：我们对最终那个” 最小的距离最大” 进行二分答案。
也就是说，我们考虑二分那个值，判断是否可行。
现在问题在于怎么O(n)判断可行。
考虑现在有两块石头i和j(i < j )它们连在一起，现在它们的距离小于二分的答案，我们现在想一下该搬哪块……
嗯……
显然是搬走j更优。
我们现在需要考虑的仅仅是这个答案是否可行，所以我们现在面临的条件就是是否能让它花费的石头最少。
考虑这样：
这里写图片描述
i和j的距离小于二分的距离，并且j和j + 1的距离也小于二分距离。
我们肯定是要继续往后走的。
我们删去i的话以后影响的距离并不受这个i石头的控制，但是我们删去j了之后，不仅消除了前面的i - > j的不合法，而且还有可能让后面的变得合法。
所以删去石头j，即当前扫到的这个石头更优。

#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstring>
#define Rep(i,n) for(int i = 1; i <= n ; i ++)
#define Rep_0(i,n) for(int i = 0 ; i < n ; i ++)
#define RD(i,x,n) for(int i = x; i <= n ; i ++)
#define CLR(a,b) memset(a,b,sizeof(a))
#define v edge[i].to
using namespace std;
int read(){
    char ch = getchar();
    while(ch < '0' || ch > '9')ch = getchar ();
    int x = 0;
    while(ch >= '0' && ch <= '9')x = 10 * x + ch - '0',ch = getchar ();
    return x;
}
int n,m,L;
int dis[50005];
bool check(int x){
    int p = 0 ,k = 0;
    Rep(i,n + 1){
        if(dis[i] - dis[k] < x)p ++;
        else k = i;
        if(p > m)return 0;
    }
    return 1;
}
int Bin_ans(int l,int r){
    if(l == r)return l; 
    int mid = l + r + 1 >> 1;
    if(check(mid))return Bin_ans(mid,r);
    return Bin_ans(l,mid - 1);
}
int main()
{
    L = read(),n = read(),m = read();
    Rep(i,n)
        dis[i] = read();
    dis[0] = 0;
    dis[n + 1] = L;
    printf("%d\n",Bin_ans(1,L));
    return 0;
}

T2.
zxn在一个月前不可置信地问fsf:”这怎么可能是一道特别简单的DP？”
现在他看到这道题：”哦我自己真是智障。”
设f[i][j][k]表示A串到i，B串到j，一共搞了k个串连起来的方案数。

(a [i] = = b [j] a n d a [i - 1]! = b [j - 1]) f [i] [j] [k] = \sum p f [p] [j - 1] [k - 1]

$(a[i] == b[j]\ and\ a[i - 1] != b[j - 1])f[i][j][k] = \sum_pf[p][j - 1][k - 1]$

(a [i] = = b [j] a n d a [i - 1] = = b [j - 1]) f [i] [j] [k] = \sum p f [p] [j - 1] [k - 1] + f [i - 1] [j - 1] [k]

$(a[i] == b[j] \ and \ a[i - 1] == b[j - 1])f[i][j][k] = \sum_pf[p][j - 1][k - 1] + f[i - 1][j - 1][k]$
前缀和 + 滚动数组优化。
这就没了啊QAQ
T3.
zxn原来一直读错题了。
他读成了使得所有的花费总和最小。
题解：使得最大的花费最小，显然二分答案。
问题是怎么check。
我们可以利用它的LCA。
我们考虑这两个点(u,v)，如果dis(u,v) >ans，那是要担责任的。
我们把u - > v的路径都标一遍，表示它们用过一遍，并且我们把距离答案最大的差记为lim。
假设我们有p条边要担责任。
当有一条边a它的边权 >= lim，且有use[a] == p，那么我们就可以删掉它了。
总的复杂度我一开始以为这是个暴力，所以一直觉得自己不会做。
现在想想每次复杂度是可以优化成O(n)的啊QAQ
考虑我们每次只标一下那两个节点和它们的LCA。
我们直接对它们到LCA的路径都加一下就好了，但是如果每一个都单独加的话显然是不优的。
我们考虑其实这个玩意可以用dfs序优化一发，就是我们每次找叶子节点进行往上的递推。
这样就是O(n)的辣QAQ
总复杂度是O(

nlog2n $nlog_2n$ )
所以zxn还是太弱了QAQ