首页 > 代码库 > Noip2008提高组总结

Noip2008提高组总结

2024-07-02 17:37:19   239人阅读

　　Noip2008前三题是基础题，仔细一些都是可以AC的，第四题的证明很巧妙，但是看懂后代码其实很简单，感觉在这些大家都不屑去做的简单题中又学到了不少，四道题代码基本都是十几二十行就够了，渐渐感觉到，比代码和算法更重要的是思想与建模，觉得下阶段应该多注意培养自己的建模能力。

T1：火柴棒等式

　　最简单的模拟题，首先记录下每种数字需要的火柴棒数，最后枚举验证即可。

+ View Code?
1
2
3
4
5
6
7
8
9
10
11
#include <cstdio>
int main(){
    int n,ans=0,a[1001],b[10]={6,2,5,5,4,5,6,3,7,6};
    scanf("%d",&n);
    for(int i=0;i<10;i++)a[i]=b[i];
    for(int i=10;i<=1000;i++)a[i]=a[i%10]+a[i/10];
    for(int i=0;i<=1000;i++)
    for(int j=i;j<=1000;j++)if(a[i]+a[j-i]+a[j]+4==n)ans++;
    printf("%d\n",ans);
    return 0;
}

T2：笨小猴

　　基础能力题，统计字符出现次数，然后直接用最简单的素数判断即可。

+ View Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
int hash[26],max,min;
bool pan(int k){
    if(k==0||k==1)return 0;
    for(int i=2;i<=(int)sqrt(k);i++)if(k%i==0)return 0;
    return 1;
}
int main(){
    char s[200]; min=100;
    scanf("%s",s);
    for(int i=0;i<strlen(s);i++)hash[s[i]-‘a‘]++;
    for(int i=0;i<26;i++){
        if(max<hash[i])max=hash[i];
        if(hash[i]&&hash[i]<min)min=hash[i];
    }int ans=max-min;
    if(pan(ans)){puts("Lucky Word");printf("%d\n",ans);}
    else{puts("No Answer");puts("0");}
    return 0;
}

T3：传纸条

　　对于这道题，其实不需要考虑从下往上传，直接考虑两条纸条从（1，1）开始传就可以了，可以采用动态规划，因为离开某个点之后，便不可能再回来。并且在转移时，判断同时转移的两点是否相同，若相同，不加数字，所以一定存在比其大的走法，不会影响结果。所以用四维Dp即可完成。

+ View Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <cstdio>
#include <algorithm>
using namespace std;
int a[55][55],f[55][55][55][55],m,n;
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)scanf("%d",&a[i][j]);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    for(int h=1;h<=n;h++)
    for(int k=1;k<=m;k++){
        f[i][j][h][k]=max(max(max(max(f[i][j][h][k],f[i-1][j][h-1][k]),f[i-1][j][h][k-1]),f[i][j-1][h][k-1]),f[i][j-1][h-1][k]);
        f[i][j][h][k]+=a[i][j];
        if(i!=h&&j!=k)f[i][j][h][k]+=a[h][k];
    }
    printf("%d\n",f[n][m][n][m]);
    return 0;
}

 　　然后可以考虑Dp的维数优化，因为纸条传的横坐标+纵坐标=走的步数，所以可以以步数为媒介将其优化为三维，代码如下：

+ View Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <cstdio>
#include <algorithm>
using namespace std;
int a[55][55],f[110][55][55],m,n;
int main() 
{ 
    scanf("%d%d",&n,&m); 
    for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)scanf("%d",&a[i][j]); 
    for(int k=1;k<=n+m-2;k++) 
    for(int i=1;i<=n;i++) 
    for(int j=1;j<=n;j++){ 
        f[k][i][j]=max(f[k-1][i-1][j],max(f[k-1][i][j-1],max(f[k-1][i][j],f[k-1][i-1][j-1]))); 
        f[k][i][j]+=a[i][k+2-i];
        if(i!=j&&k+2-i>=1&&k+2-j>=1)f[k][i][j]+=a[j][k+2-j];
    }
    printf("%d",f[n+m-2][n][n]); 
    return 0; 
} 

 注意界限k+2-i>=1&&k+2-j>=1

T4：双栈排序

　　首先给出结论P: S[i],S[j]两个元素不能进入同一个栈 等价于 存在k,满足i<j<k,使得S[k]<S[i]<S[j]. 

证明：

　　考虑对于任意两个数q1[i]和q1[j]来说,它们不能压入同一个栈中的充要条件是什么(注意没有必要使它们同时存在于同一个栈中,只是压入了同一个栈).实际上,这个条件p是:存在一个k,使得i<j<k且q1[k]<q1[i]<q1[j].
　　首先证明充分性,即如果满足条件p,那么这两个数一定不能压入同一个栈.这个结论很显然,使用反证法可证.
　　假设这两个数压入了同一个栈,那么在压入q1[k]的时候栈内情况如下:
　　…q1[i]…q1[j]…
　　因为q1[k]比q1[i]和q1[j]都小,所以很显然,当q1[k]没有被弹出的时候,另外两个数也都不能被弹出(否则q2中的数字顺序就不是1,2,3,…,n了).
而之后,无论其它的数字在什么时候被弹出,q1[j]总是会在q1[i]之前弹出.而q1[j]>q1[i],这显然是不正确的.
　　接下来证明必要性.也就是,如果两个数不可以压入同一个栈,那么它们一定满足条件p.这里我们来证明它的逆否命题,也就是"如果不满足条件p,那么这两个数一定可以压入同一个栈."
　　不满足条件p有两种情况:一种是对于任意i<j<k且q1[i]<q1[j],q1[k]>q1[i];另一种是对于任意i<j,q1[i]>q1[j].
　　第一种情况下,很显然,在q1[k]被压入栈的时候,q1[i]已经被弹出栈.那么,q1[k]不会对q1[j]产生任何影响(这里可能有点乱,因为看起来,当q1[j]<q1[k]的时候,是会有影响的,但实际上,这还需要另一个数r,满足j<k<r且q1[r]<q1[j]<q1[k],也就是证明充分性的时候所说的情况…而事实上我们现在并不考虑这个r,所以说q1[k]对q1[j]没有影响).
　　第二种情况下,我们可以发现这其实就是一个降序序列,所以所有数字都可以压入同一个栈.
　　这样,原命题的逆否命题得证,所以原命题得证.
　　此时,条件p为q1[i]和q1[j]不能压入同一个栈的充要条件也得证.

　　这样,我们对所有的数对(i,j)满足1<=i<j<=n,检查是否存在i<j<k满足p1[k]<p1[i]<p1[j].
　　二分图的两部分看作两个栈,因为二分图的同一部分内不会出现任何连边,也就相当于不能压入同一个栈的所有结点都分到了两个栈中.
　　此时我们只考虑检查是否有解,所以只要O(n)检查出这个图是不是二分图,就可以得知是否有解.
　　此时,检查有解的问题已经解决.接下来的问题是,如何找到字典序最小的解.
　　实际上,可以发现,如果把二分图染成1和2两种颜色,那么结点染色为1对应当前结点被压入s1,为2对应被压入s2.为了字典序尽量小,我们希望让编号小的结点优先压入s1.
　　又发现二分图的不同连通分量之间的染色是互不影响的,所以可以每次选取一个未染色的编号最小的结点,将它染色为1并从它开始DFS染色,直到所有结点都被染色为止.这样,我们就得到了每个结点应该压入哪个栈中.接下来要做的,只不过是模拟之后输出序列啦。
　　还有就是注意复杂度的优化，如果对于数对(i,j),都去枚举检查是否存在k使得p1[k]<p1[i]<p1[j]的话,那么复杂度就升到了O(n^3).解决方法就是,首先预处理出数组min,min[i]表示从p1[i]到p1[n]中的最小值.接下来,只需要枚举所有数对(i,j),检查min[j+1]是否小于p1[i]且p1[i]是否小于p1[j]就可以了.

+ View Code?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <cstdio>
int color[1005],min[1005],a[1005],s1[1005],s2[1005];
int n,m,i,j,k,t1,t2,now,sum;
const int INF=~0U>>1; 
bool dfs(int x,int co){ 
    if(color[x]==0)color[x]=co; 
    else return color[x]==co; 
    for(int i=1;i<x;i++)if(a[i]<a[x]&&min[x+1]<a[i]&&!dfs(i,3-co))return 0; 
    for(int i=x+1;i<=n;i++)if(a[x]<a[i]&&min[i+1]<a[x]&&!dfs(i,3-co))return 0;
    return 1; 
}
int main(){ 
    scanf("%d",&n); 
    for(int i=1;i<=n;i++)scanf("%d",&a[i]); min[n+1]=INF; 
    for(int i=n;i>=1;i--){min[i]=min[i+1];if(a[i]<min[i])min[i]=a[i];} 
    for(int i=1;i<=n;i++)if(color[i]==0&&!dfs(i,1)){puts("0");return 0;}
    now=1; t1=t2=0; 
    for(int i=1;i<=n;i++){ 
        if(color[i]==1){printf("a ");s1[++t1]=a[i];} 
        else{printf("c ");s2[++t2]=a[i];} 
        while(s1[t1]==now||s2[t2]==now){ 
            if(s1[t1]==now++){t1--;printf("b ");} 
            else{t2--;printf("d ");} 
        } 
    }
    return 0;
}

注意点：

　　1.Dp特别注意边界问题；

　　2.Dp维数优化可以通过找中间量来实现，比如T3中的步数；

　　3.注意是puts("0")而不是puts(0)，否则会结果错误，但是编译可通过；

　　4.不得不提自己又被双等号坑了一次，特别注意!!!　　


联系
我们