NOIP2010 机器翻译 乌龟棋 关押罪犯

NOIP2010

第一题
题目较简单，可以直接模拟，used【】存内存中的数，如果溢出就删除。

#include <iostream>
#include <cstdio>
using namespace std;

const int N = 1010;

int used[N], a[N];
int tot, b ,j;

int main(){
    freopen("translate.in","r",stdin);
    freopen("translate.out","w",stdout);
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i=1; i<=m; i++){
        j++;
        scanf("%d", &a[j]);
        if(used[a[j]] == 0){
            used[a[j]]++; tot++; b++;
            if(b > n) used[a[j-n]]--;
            if(used[a[j-n]] < 0) used[a[j-n]] = 0;//不允许减为负
        }
        else j--;
    }
    printf("%d", tot);
    return 0;
}

第二题
又是一道明显的dp题，但是针对这道题目特有的优化却不容易想到。关键就是要仔细分析数据范围（每种卡片的张数不超过四十！！！）这就是提示我们如何dp的最关键信息。因为四张卡片的用量一旦确定下来，乌龟所在的位置也就确定下来了。少一张几步的卡片就从几步之前的位置转移而来，状态转移的方程是很容易写的。所以四维的dp解决问题。

#include<iostream>
#include<cstdio>
#include <algorithm>
using namespace std;

int m,k,t;
int c[150],f[41][41][41][41],v[355],sum[5];

int main()
{
    freopen("tortoise.in","r",stdin);
    freopen("tortoise.out","w",stdout);
    scanf("%d%d",&t,&m);
    for(int i=1; i<=t; i++)
        scanf("%d",&v[i]);
    for(int i=1; i<=m; i++){
        scanf("%d",&c[i]);
        sum[c[i]]++;
    }
    f[0][0][0][0] = v[1];
    for(int i=0; i<=sum[1]; i++)
    for(int j=0; j<=sum[2]; j++)
    for(int k=0; k<=sum[3]; k++)
    for(int l=0; l<=sum[4]; l++){ 
        int s = i + 2*j + 3*k + 4*l + 1; 
        if(i > 0)
        f[i][j][k][l] = max(f[i][j][k][l], f[i-1][j][k][l] + v[s]);
        if(j > 0)
        f[i][j][k][l] = max(f[i][j][k][l], f[i][j-1][k][l] + v[s]);
        if(k > 0)
        f[i][j][k][l] = max(f[i][j][k][l], f[i][j][k-1][l] + v[s]);
        if(l > 0)
        f[i][j][k][l] = max(f[i][j][k][l], f[i][j][k][l-1] + v[s]);
    }   
    printf("%d",f[sum[1]][sum[2]][sum[3]][sum[4]]);
    return 0;
}

第三题
这是一道用并差集解决的题目，这里有一个最优的思想，就是要先处理权值高的遍，因为最终的结果由最大值决定，所以说如果大的遍不能解决，小的遍就没什么意义了。所以我们存完遍后，先排一次序，然后从大到小地模拟放点入栈的操作，直到产生矛盾，就取用最大值作为答案。还有就是如果在模拟的过程中遇见没法确定放入哪个栈的情况，就先不管它，打上一个标记，等有新的点被放入栈之后，再返回来判断。因为是在编的中途想到的并查集，下面的代码并不是标准的并查集，只是采用了并查集的思想。而且可能有一些瑕疵，仅供参考。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 100010;

int fam[20010], used[N];

struct ln{
    int sum;
    int p1, p2;
}ed[N];

bool mycmp(ln a,ln b){
    return a.sum > b.sum;
}

int main()
{
    freopen("prison.in","r",stdin);
    freopen("prison.out","w",stdout);
    memset(fam, -1, sizeof(fam));
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i=1; i<=m; i++){
        scanf("%d%d%d", &ed[i].p1, &ed[i].p2, &ed[i].sum);
    }
    sort(ed+1,ed+1+m,mycmp);
    fam[ed[1].p1] = 0; fam[ed[1].p2] = 1; used[1] = 1;
    int k = 2, nxt = 1, flag = 0;
    while(ed[k].sum){
        int u1 = ed[k].p1; 
        int u2 = ed[k].p2;
        if(fam[u1] == -1 && fam[u2] > -1 && used[k] == 0){
            fam[u1] = (fam[u2] + 1) % 2;
            used[k] = 1;
            k = nxt-1; 
            nxt = 1;
        }
        else if(fam[u2] == -1 && fam[u1] > -1 && used[k] == 0){
            fam[u2] = (fam[u1] + 1) % 2;
            used[k] = 1;
            k = nxt-1;
            nxt = 1;
        }
        else if(fam[u2] == -1 && fam[u1] == -1 && nxt == 1){
            nxt = k;
        }
        else if(fam[u2] > -1 && fam[u1] > -1 && used[k] == 0 && fam[u2] == fam[u1]){
            printf("%d", ed[k].sum);
            flag = 1;
            break;
        }
        k++;
    }
    if(flag == 0) printf("%d", 0);
    return 0;
}

第四题
用dfs实现本题是一个很容易想到的思路，但是有一个问题就是我们如何找出一个最优解呢？dfs可以帮助我们判断输出0 or 1（打标记），如果是1，我们就需要找最优解，那么简单的证明一下，由一个临水城市可以到达的沙漠城市一定是一条连续的线段，可以用反证法论证，如果不连续，这个断点就会由另一个临水城市到达，那么这两个临水城市覆盖的位置就一定会交叉，那么交叉点下面的城市（断点）就一定可以被这两个城市共同覆盖。于是就可以采用线段覆盖（类似dp）的方法快速求得最优。因为数据里有一个点会卡dfs，所以说经过反复尝试，用c提交+register不会T掉。

#include<string.h>
#include<stdio.h>
inline int readin(){
    static char ch;
    static int res;
    while((ch=getchar())>'9'||ch<'0');res=ch-48;
    while((ch=getchar())>='0'&&ch<='9')res=res*10+ch-48;
    return res;
}
int n, m, num = 0;
int vis[510][510], ans[510] ,pos[510][510], f[510];
struct ln{
     int l,r;
}ed[510];

int min(int a, int b){
    return a<b?a:b;
}

int max(int a, int b){
    return a>b?a:b;
}

void dfs(int x,int y,int st)
{
     vis[x][y] = 1;
     if(x == m){
          ans[y] = 1;
          ed[st].l = min(ed[st].l, y);
          ed[st].r = max(ed[st].r, y);
     }
     if(pos[x+1][y] < pos[x][y] && x != m && !vis[x+1][y]) dfs(x+1,y,st);
     if(pos[x-1][y] < pos[x][y] && x != 1 && !vis[x-1][y]) dfs(x-1,y,st);
     if(pos[x][y+1] < pos[x][y] && y != n && !vis[x][y+1]) dfs(x,y+1,st);
     if(pos[x][y-1] < pos[x][y] && y != 1 && !vis[x][y-1]) dfs(x,y-1,st);
}

int main()
{
    freopen("flow.in","r",stdin);
    freopen("flow.out","w",stdout);
    m=readin(),n=readin();
    for(register int i=1; i<=n; i++)
        ed[i].l = f[i] = 10000000;
    for(register int i=1; i<=m; i++)
    for(register int j=1; j<=n; j++)
        pos[i][j]=readin();
    for(register int i=1; i<=n; i++){
        memset(vis, 0, sizeof(vis));
        dfs(1, i, i);
    }
    for(register int i=1; i<=n; i++)
      if(ans[i] == 0) num++;
    if(num > 0) {
        printf("%d\n%d", 0, num);
        return 0;
    }
    else{
        printf("1\n");
        for(register int i=1; i<=n; i++)
        for(register int j=1; j<=n; j++){
            if(i >= ed[j].l && i <= ed[j].r)
            f[i] = min(f[i], f[ed[j].l - 1] + 1);
        }
        printf("%d", f[n]);
    }
    return 0;
}

考试总结
一次10年noip真题练习。一般来说第一道题比较简单，这一次还没有摸清题目，所以说第一道题的耗时较长，原因就是把题目想的过于复杂，其实用常规方法10min就完全可以解决，这样就耽误了之后做题的时间。第二题是一个四维的dp，最开始想的是五维，没有想到简化的方法，这类题目其实难度并不大，但是需要想出巧一点的方法。第三题是一个并查集的题目，思想没有问题，不过代码不够规范，导致最后一个点没有调出来。最后一道是dp+区间覆盖，当时没有严格的证明区间的正确性，方法不太好想，其中有一个测试点要卡dfs，最后用c语言提交没有超时（不能用algorithm，加.h，不能在for中定义变量）。