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]=1;
    for(int i=0;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]=1;
    cmp[x]=cnt;
    m[cnt]=max(m[cnt],x);
    for(int i=0;i<rG[x].size();i++){
        int y=rG[x][i];
        if(!b[y]){
            dfs2(y);
        }
    }
}
void suo(int x){
    b[x]=1;
    for(int i=0;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]=1;
    for(int i=0;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=1;i<=E;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        G[x].push_back(y);
        rG[y].push_back(x);
    }
    memset(b,0,sizeof(b));
    for(int i=1;i<=V;i++){
        if(!b[i]){
            dfs1(i);
        }
    }
    memset(b,0,sizeof(b));
    for(int i=vs.size()-1;i>=0;i--){
        cnt++;
        int x=vs[i];
        if(!b[x]){
            dfs2(x);
        }
    }
    memset(b,0,sizeof(b));
    for(int i=1;i<=V;i++){
        if(!b[i]){
            suo(i);
        }
    }
    memset(b,0,sizeof(b));
    for(int i=1;i<=cnt;i++){
        if(!ru[i]){
            topoSort(i);
        }
    }
    for(int i=1;i<=V;i++){
        printf("%d ",m[cmp[i]]);
    }
    return 0;
}

---

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=0;
int a[MAXN];
int f[MAXN];
int n;
int max_array(){
    int ret=0;
    for(int i=1;i<=n;i++){
        pii t=make_pair(a[i],0);
        // lower_bound the key should be the same
        int Pos=lower_bound(s+1,s+top+1,t)-s;
        f[i]=s[Pos-1].second+1;
        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=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    int len=n-max_array();
    printf("%d\n",len);
    return 0;
}

---

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=0;
        memset(s,0,sizeof(s));
    }
    BigInt operator = (const BigInt &A){
        len=A.len;
        for(int i=1;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=1;i<=L;i++){
            t.s[i]*=B;
        }
        for(int i=1;i<=L;i++){
            t.s[i+1]+=(t.s[i]/10);
            t.s[i]%=10;
        }
        while(t.s[L+1]){
            L++;
            t.s[L+1]+=(t.s[L]/10);
            t.s[L]%=10;
        }
        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=1;i<=L;i++){
            t.s[i]=A.s[i]+B.s[i];
        }
        for(int i=1;i<=L;i++){
            t.s[i+1]+=(t.s[i]/10);
            t.s[i]%=10;
        }
        if(t.s[L+1]){
            L++;
        }
        t.len=L;
        return t;
    }
    void Print(){
        for(int i=len;i>=1;i--){
            printf("%d",s[i]);
        }
        printf("\n");
    }
    
}f[MAXN][MAXN];
int n,k;
int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++){
        f[i][0].len=1,f[i][0].s[1]=1;
    }
    for(int i=2;i<=n;i++){
        for(int j=1;j<n;j++){
            f[i][j]=f[i-1][j-1]*(i-j)+f[i-1][j]*(j+1);
        }
    }
    f[n][k].Print();
    return 0;
}

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