2014-10-30NOIP复习题1

Problem 1 Graph (graph.cpp/c/pas)

【题目描述】

给出 N 个点，M 条边的有向图，对于每个点 v，求 A(v) 表示从点 v 出发，能到达的编号最大的点。

【输入格式】

第 1 行，2 个整数 N,M。 接下来 M 行，每行 2 个整数 Ui,Vi，表示边 ⟨Ui,Vi⟩。点用 1,2,...,N 编号。

【输出格式】

N 个整数 A(1),A(2),...,A(N)。

【样例输入】

4 3

1 2

2 4

4 3

【样例输出】

4 4 3 4

【数据范围】

对于 60% 的数据，1 ≤ N,K ≤ 10^3

对于 100% 的数据，1 ≤ N,M ≤ 10^5。

Problem 2 Incr(incr.cpp/c/pas)

【题目描述】

数列 A1,A2,...,AN，修改最少的数字，使得数列严格单调递增。

【输入格式】

第 1 行，1 个整数 N

第 2 行，N 个整数 A1,A2,...,AN

【输出格式】

1 个整数，表示最少修改的数字

【样例输入】

3

1 3 2

【样例输出】

1

【数据范围】

对于 50% 的数据，N ≤ 10^3

对于 100% 的数据，1 ≤ N ≤ 10^5,1 ≤ Ai ≤ 10^9

Problem 3 Permutation (permutation.cpp/c/pas)

【题目描述】

将 1 到 N 任意排列，然后在排列的每两个数之间根据他们的大小关系插入“>”和“<”。

问在所有排列中，有多少个排列恰好有K个“<”。

例如排列(3, 4, 1, 5, 2)

3 < 4 > 1 < 5 > 2

共有2个“<”

【输入格式】

N,K

【输出格式】

答案

【样例输入】

5 2

【样例输出】

66

【数据范围】

20%：N <= 10

50%：答案在0..2^63-1内

100%：K < N <= 100

---

NOIP复习题旨在复习知识点，故写详细一点啦

T1:

强联通分量缩点的裸题（我当时竟然以为第一题应该不会太难而没考虑环，结果40分炸掉QAQ）

我用的是Kosaraj+dfs缩点，效率很低

不过还是写一下吧，反正我不会tarjan~

先是两遍深搜获取基本信息，然后再一遍深搜把各个缩点连接起来

最后一遍拓扑排序。

总共四边搜索，四次清空bool数组，三个邻接表

程序太垃圾啦~

 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 #define MAXN 100005
 using namespace std;
 vector<int> G[MAXN];
 vector<int> rG[MAXN];
 vector<int> nG[MAXN];
 vector<int> vs;
 int cmp[MAXN],cnt;
 int m[MAXN];
 int b[MAXN];
 int ru[MAXN];
 int V,E;
 void dfs1(int x){
     b[x]=;
     for(int i=;i<G[x].size();i++){
         int y=G[x][i];
         if(!b[y]){
             dfs1(y);
         }
     }
     vs.push_back(x);
 }
 void dfs2(int x){
     b[x]=;
     cmp[x]=cnt;
     m[cnt]=max(m[cnt],x);
     for(int i=;i<rG[x].size();i++){
         int y=rG[x][i];
         if(!b[y]){
             dfs2(y);
         }
     }
 }
 void suo(int x){
     b[x]=;
     for(int i=;i<G[x].size();i++){
         int y=G[x][i];
         if(cmp[x]!=cmp[y]){
             nG[cmp[x]].push_back(cmp[y]);
             ru[cmp[y]]++;
         }
         if(!b[y]){
             suo(y);
         }
     }
 }
 void topoSort(int x){
     b[x]=;
     for(int i=;i<nG[x].size();i++){
         int y=nG[x][i];
         if(!b[y]){
             topoSort(y);
         }
         m[x]=max(m[x],m[y]);
     }
 }
 int main()
 {
 //    freopen("data.in","r",stdin);
     scanf("%d%d",&V,&E);
     for(int i=;i<=E;i++){
         int x,y;
         scanf("%d%d",&x,&y);
         G[x].push_back(y);
         rG[y].push_back(x);
     }
     memset(b,,sizeof(b));
     for(int i=;i<=V;i++){
         if(!b[i]){
             dfs1(i);
         }
     }
     memset(b,,sizeof(b));
     for(int i=vs.size()-;i>=;i--){
         cnt++;
         int x=vs[i];
         if(!b[x]){
             dfs2(x);
         }
     }
     memset(b,,sizeof(b));
     for(int i=;i<=V;i++){
         if(!b[i]){
             suo(i);
         }
     }
     memset(b,,sizeof(b));
     for(int i=;i<=cnt;i++){
         if(!ru[i]){
             topoSort(i);
         }
     }
     for(int i=;i<=V;i++){
         printf("%d ",m[cmp[i]]);
     }
     return ;
 }

Code1

---

T2:

其实就是n-最大上升序列长度即可

证明如下：

设m=n-最长上升序列长度

1）改变m次一定足以使数列递增

2）改变不到m次一定不足以使数列递增

依次证明：

1）显然成立。。。

2）不到m次，那么就设为x吧(x<m)

那么假设x次操作改变的数列项为b1,b2,……,bx

无视这x项，剩余的项数一定是递增的，即此时上升序列长度为n-x

出现了矛盾：最长上升序列=n-m<n-x

于是得证

然后问题是最长上升序列我竟然有点忘记了

巩固一下：

建立单调栈，使得a[i]<a[i+1]

对于新插入的元素a[i]，查找大于等于（注意这里是大于等于，因为是严格递增的，所以不能出现相同）第一个a[Pos]

f[i]=f[Pos-1]+1，然后直接用a[i]更新a[Pos]，原因a[i]和a[Pos]的f相同的，但a[i]<=a[Pos]，所以状态会更优

 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 #include<cstring>
 #define MAXN 100005
 #define pii pair<int,int>
 using namespace std;
 pii s[MAXN];
 int top=;
 int a[MAXN];
 int f[MAXN];
 int n;
 int max_array(){
     int ret=;
     for(int i=;i<=n;i++){
         pii t=make_pair(a[i],);
         // lower_bound the key should be the same
         int Pos=lower_bound(s+,s+top+,t)-s;
         f[i]=s[Pos-].second+;
         ret=max(f[i],ret);
         if(Pos>top){
             top++;
         }
         s[Pos]=make_pair(a[i],f[i]);
     }
     return ret;
 }
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;i++){
         scanf("%d",&a[i]);
     }
     int len=n-max_array();
     printf("%d\n",len);
     return ;
 }

Code2

---

T3:

这题我做过啊

f[i][j]=f[i-1][j-1]*(i-j)+f[i-1][j]*(j+1)

边界f[1~n][0]=1

关键就是复习一下高精度了

 #include<cstdio>
 #include<cstdlib>
 #include<algorithm>
 #include<cstring>
 #define MAXN 105
 #define SIZE 1000
 using namespace std;
 struct BigInt{
     int len;
     int s[SIZE];
     BigInt(){
         len=;
         memset(s,,sizeof(s));
     }
     BigInt operator = (const BigInt &A){
         len=A.len;
         for(int i=;i<=len;i++){
             s[i]=A.s[i];
         }
         return *this;
     }
     friend BigInt operator * (const BigInt &A,const int B){
         BigInt t;
         t=A;
         int L=t.len;
         for(int i=;i<=L;i++){
             t.s[i]*=B;
         }
         for(int i=;i<=L;i++){
             t.s[i+]+=(t.s[i]/);
             t.s[i]%=;
         }
         while(t.s[L+]){
             L++;
             t.s[L+]+=(t.s[L]/);
             t.s[L]%=;
         }
         t.len=L;
         return t;
     }
     friend BigInt operator + (const BigInt &A,const BigInt &B){
         BigInt t;
         t.len=max(A.len,B.len);
         int L=t.len;
         for(int i=;i<=L;i++){
             t.s[i]=A.s[i]+B.s[i];
         }
         for(int i=;i<=L;i++){
             t.s[i+]+=(t.s[i]/);
             t.s[i]%=;
         }
         if(t.s[L+]){
             L++;
         }
         t.len=L;
         return t;
     }
     void Print(){
         for(int i=len;i>=;i--){
             printf("%d",s[i]);
         }
         printf("\n");
     }

 }f[MAXN][MAXN];
 int n,k;
 int main()
 {
     scanf("%d%d",&n,&k);
     for(int i=;i<=n;i++){
         f[i][].len=,f[i][].s[]=;
     }
     for(int i=;i<=n;i++){
         for(int j=;j<n;j++){
             f[i][j]=f[i-][j-]*(i-j)+f[i-][j]*(j+);
         }
     }
     f[n][k].Print();
     return ;
 }

Code3

总结：基础知识很重要啊，要不然真是有苦说不出。。。