vjudge个人赛复习1

A - 大鱼吃小鱼（栈）

有N条鱼每条鱼的位置及大小均不同，他们沿着X轴游动，有的向左，有的向右。游动的速度是一样的，两条鱼相遇大鱼会吃掉小鱼。从左到右给出每条鱼的大小和游动的方向（0表示向左，1表示向右）。问足够长的时间之后，能剩下多少条鱼？Input第1行：1个数N，表示鱼的数量(1 <= N <= 100000)。
第2 - N + 1行：每行两个数A[i], B[i]，中间用空格分隔，分别表示鱼的大小及游动的方向(1 <= A[i] <= 10^9，B[i] = 0 或 1，0表示向左，1表示向右）。Output输出1个数，表示最终剩下的鱼的数量。Sample Input

Sample Output

/*

    对于第i条鱼，如果方向朝右进栈。向左的话，跟栈每一个元素j比较，如果i>j   那么j死，继续访问j前面的元素(知道栈空或者死),,, 否则i死，  继续遍历i+1以及后面的元素

*/

#include<iostream>

#include<cstdio>

using namespace std;

#define maxn 100010

int st[maxn],top,n,cnt;

int main(){

    scanf("%d",&n);cnt=n;

    int x,y;

    for(int i=;i<=n;i++){

        scanf("%d%d",&x,&y);

        if(y==)st[++top]=x;

        else{

            while(top){

                if(x>st[top]){top--;cnt--;}

                else {cnt--;break;}

            }

        }

    }

    cout<<cnt;

}

AC代码用栈维护

B - 线段的重叠（贪心）

X轴上有N条线段，每条线段包括1个起点和终点。线段的重叠是这样来算的，[10 20]和[12 25]的重叠部分为[12 20]。

给出N条线段的起点和终点，从中选出2条线段，这两条线段的重叠部分是最长的。输出这个最长的距离。如果没有重叠，输出0。

Input第1行：线段的数量N(2 <= N <= 50000)。
第2 - N + 1行：每行2个数，线段的起点和终点。(0 <= s , e <= 10^9)Output输出最长重复区间的长度。Sample Input

Sample Output

#include<iostream>

#include<cstdio>

#include<algorithm>

#define maxn 50010

using namespace std;

int n;

struct node{

    int l,r;

    bool operator < (const node a)const{

        return l<a.l;

    }

}e[maxn];

int main(){

    scanf("%d",&n);

    for(int i=;i<=n;i++)

        scanf("%d%d",&e[i].l,&e[i].r);

    sort(e+,e+n+);

    int ans=;

    for(int i=;i<=n;i++)

        for(int j=i+;j<=n;j++){

            if(e[i].r>e[j].r)

                ans=max(ans,e[j].r-e[j].l);

            else

                ans=max(ans,e[i].r-e[j].l);

        }

    cout<<ans;

}

80分 n^2暴力

/*

    贪心，按照线段左端点升序排序，

    左端点相等，右端点降序排序

*/

#include<iostream>

#include<algorithm>

#include<cmath>

using namespace std;

const int MAX=;

struct Node{

    int b,e;

};

Node a[MAX];

int cmp(Node p1,Node p2){

    if(p1.b<p2.b) return ;

    else if(p1.b==p2.b&&p1.e>p2.e) return ;

    return ;

}

int main()

{

    int n;

    while(cin>>n){

        for(int i=;i<n;i++){

            cin>>a[i].b>>a[i].e;

        }

        sort(a,a+n,cmp);

        int res=;

        Node s=a[];

        for(int i=;i<n;i++){

            if(a[i].e<=s.e){//线段i在线段i-1内

                res=max(res,a[i].e-a[i].b);

            }

            else if(a[i].b<=s.e&&a[i].e>s.e){

                res=max(res,s.e-a[i].b);

                s=a[i];//选择最靠后的线段

            }

            else s=a[i];

        }

        cout<<res<<endl;

    }

    return ;

}

100分贪心

C - 3个数和为0（暴力枚举）

给出一个长度为N的无序数组，数组中的元素为整数，有正有负包括0，并互不相等。从中找出所有和 = 0的3个数的组合。如果没有这样的组合，输出No Solution。如果有多个，按照3个数中最小的数从小到大排序，如果最小的数相等则按照第二小的数排序。

Input第1行，1个数N，N为数组的长度(0 <= N <= 1000)
第2 - N + 1行：A[i]（-10^9 <= A[i] <= 10^9)Output如果没有符合条件的组合，输出No Solution。
如果有多个，按照3个数中最小的数从小到大排序，如果最小的数相等则继续按照第二小的数排序。每行3个数，中间用空格分隔，并且这3个数按照从小到大的顺序排列。Sample Input

Sample Output

#include<iostream>

#include<cstdio>

#include<algorithm>

using namespace std;

#define maxn 1010

int n,a[maxn],b[];

void dfs(int pos,int cnt,int sum){

    if(cnt==){

        if(sum==){

            for(int i=;i<=;i++)printf("%d ",b[i]);

            printf("\n");

        }

        return;

    }

    if(pos>n)return;

    for(int i=pos;i<=n;i++){

        b[cnt]=a[i];

        dfs(i+,cnt+,sum+a[i]);

    }

}

int main(){

    scanf("%d",&n);

    for(int i=;i<=n;i++)scanf("%d",&a[i]);

    sort(a+,a+n+);

    dfs(,,);//到底几个数了，已经确定了几个数-1，目前的和

}

60分暴力

#include<iostream>

#include<cstdio>

#include<algorithm>

using namespace std;

#define maxn 1010

int n,a[maxn];

bool flag;

int main(){

    scanf("%d",&n);

    for(int i=;i<=n;i++)scanf("%d",&a[i]);

    sort(a+,a+n+);

    for(int i=;i<=n;i++)

        for(int j=i+;j<=n;j++)

            for(int k=j+;k<=n;k++)

                if(a[i]+a[j]+a[k]==){

                    flag=;

                    printf("%d %d %d\n",a[i],a[j],a[k]);

                }

    if(!flag)printf("No Solution");

    return ;

}

100分枚举n^3

D - 复杂度n^2log(n^2)（折半枚举）

给出N个整数，你来判断一下是否能够选出4个数，他们的和为0，可以则输出"Yes"，否则输出"No"。Input第1行，1个数N，N为数组的长度(4 <= N <= 1000)
第2 - N + 1行：A[i]（-10^9 <= A[i] <= 10^9)Output如果可以选出4个数，使得他们的和为0，则输出"Yes"，否则输出"No"。Sample Input

Sample Output

Yes

#include<iostream>

#include<cstdio>

#include<map>

#include<algorithm>

using namespace std;

int n,a[];

map<int,bool>f;

int main(){

    scanf("%d",&n);

    for(int i=;i<=n;i++)scanf("%d",&a[i]);

    sort(a+,a+n+);

    int mid=n/;

    for(int i=;i<=mid;i++){

        for(int j=i+;j<=mid;j++){

            int x=a[i]+a[j];

            f[x]=;

        }

    }

    for(int i=mid+;i<=n;i++){

        for(int j=i+;j<=n;j++){

            int x=-(a[i]+a[j]);

            if(f[x]){

                printf("Yes");

                return ;

            }

        }

    }

    printf("No");

    return ;

}

排序+暴力+二分1

#include<iostream>

#include<stdio.h>

#include<algorithm>

using namespace std;

int a[];

int main(){

    int n;

    scanf("%d",&n);

    for(int i=;i<n;i++)

        scanf("%d",&a[i]);

    sort(a,a+n);

    for(int i=;i<n;i++)

        for(int j=i+;j<n;j++){

            int k,m,sum;

            k=j+;

            m=n-;

            while(k<m) {

                sum=a[i]+a[j]+a[k]+a[m];

                if(sum<)k++;

                else if(sum>)m--;

                else{

                    k++;m--;

                    printf("Yes\n");

                    return ;

                }

            }

        }

    printf("No\n");

    return ;

}

排序+暴力+二分2

/*

    还有个很好的思路，先把数组中任意两个数存起来，再从小到大排序，类似二分的思想从两头开始查找，是否满足sum1+sum2==0 并且两个坐标不重叠，每个点只选一次

*/

#include <iostream>

#include <stdio.h>

#include <algorithm>

using namespace std;

int a[];

struct node{

    int x, y;

    int sum;

}P[*];

int cmp(node a, node b) {

    return a.sum < b.sum;

}

int main(){

    int n;

    scanf("%d", &n);

    for(int i=;i<n;i++)scanf("%d",&a[i]);

    int k=;

    for(int i=;i<n;i++)

        for(int j=i+;j<n;j++) {

            P[k].x=a[i];

            P[k].y=a[j];

            P[k++].sum=a[i]+a[j];

        }

    sort(P,P+k,cmp);

    int l=,r=k-;

    int flag=;

    while(l<r){

        if (P[l].sum+P[r].sum==&&P[l].x!=P[r].x&&P[l].y!=P[r].y&&P[l].x!=P[r].y&&P[l].y!=P[r].x){

            flag = ;

            break;

        }

        else if(P[l].sum+P[r].sum<)l++;

        else r--;

    }

    if (flag)printf("Yes\n");

    else printf("No\n");

    return ;

}

一种新做法

E - 和为K的组合（搜索）

给出N个正整数组成的数组A，求能否从中选出若干个，使他们的和为K。如果可以，输出："Yes"，否则输出"No"。Input第1行：2个数N, K, N为数组的长度, K为需要判断的和(2 <= N <= 20，1 <= K <= 10^9)
第2 - N + 1行：每行1个数，对应数组的元素A[i] (1 <= A[i] <= 10^6)Output如果可以，输出："Yes"，否则输出"No"。Sample Input

Sample Output

No

#include<iostream>

#include<cstdio>

using namespace std;

int n,k,a[];

bool flag;

void dfs(int pos,int sum){

    if(sum==k){

        flag=;

        return;

    }

    if(pos>=n)return;

    if(flag)return;

    for(int i=pos+;i<=n;i++)

        dfs(i,sum+a[i]);

}

int main(){

    scanf("%d%d",&n,&k);

    for(int i=;i<=n;i++)scanf("%d",&a[i]);

    if(k==){

        printf("Yes");

        return ;

    }

    dfs(,);

    if(flag){

        printf("Yes");

        return ;

    }

    else printf("No");

    return ;

}

AC代码直接深搜

F - 数组中和等于K的数对（枚举+二分）

给出一个整数K和一个无序数组A，A的元素为N个互不相同的整数，找出数组A中所有和等于K的数对。例如K = 8，数组A：{-1,6,5,3,4,2,9,0,8}，所有和等于8的数对包括(-1,9)，(0,8)，(2,6)，(3,5)。

Input第1行：用空格隔开的2个数，K N，N为A数组的长度。(2 <= N <= 50000，-10^9 <= K <= 10^9)
第2 - N + 1行：A数组的N个元素。（-10^9 <= A[i] <= 10^9)Output第1 - M行：每行2个数，要求较小的数在前面，并且这M个数对按照较小的数升序排列。
如果不存在任何一组解则输出：No Solution。Sample Input

Sample Output

#include<iostream>

#include<cstdio>

#include<algorithm>

using namespace std;

int k,n,a[];

bool flag;

int main(){

    //freopen("Cola.txt","r",stdin);

    scanf("%d%d",&k,&n);

    for(int i=;i<=n;i++)scanf("%d",&a[i]);

    sort(a+,a++n);

    for(int i=;i<n;i++){

        int l=i+,r=n;

        int x=k-a[i];

        int pos=lower_bound(a+i+,a+n+,x)-a;

        if(a[pos]!=x)continue;

        else printf("%d %d\n",a[i],a[pos]),flag=;

    }

    if(!flag){

        printf("No Solution");

        return ;

    }

    return ;

}

AC代码枚举+二分

G - 活动安排问题（贪心&线段覆盖）

有若干个活动，第i个开始时间和结束时间是[Si,fi)，同一个教室安排的活动之间不能交叠，求要安排所有活动，最少需要几个教室？
Input第一行一个正整数n (n <= 10000)代表活动的个数。
第二行到第(n + 1)行包含n个开始时间和结束时间。
开始时间严格小于结束时间，并且时间都是非负整数，小于1000000000Output一行包含一个整数表示最少教室的个数。Sample Input

Sample Output

#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

#define maxn 10010

using namespace std;

int n;

bool vis[maxn];

struct node{

    int s,t;

    bool operator < (const node b)const{

        return t>b.t;

    }

}a[maxn];

int main(){

    scanf("%d",&n);

    for(int i=;i<=n;i++)scanf("%d%d",&a[i].s,&a[i].t);

    sort(a+,a+n+);

    memset(vis,,sizeof(vis));

    int ans=;

    while(){

        int p,st;

        bool flag=;

        for(int i=;i<=n;i++){

            if(!vis[i]){

                p=i;

                vis[p]=;

                flag=;

                break;

            }

        }

        if(!flag)break;

        ans++;st=p;

        for(int i=st+;i<=n;i++){

            if(!vis[i]&&a[i].t<=a[p].s){

                vis[i]=;

                p=i;

            }

        }

    }

    printf("%d",ans);

    return ;

}

AC代码贪心

H - Anigram单词（唯一分解定理）

一个单词a如果通过交换单词中字母的顺序可以得到另外的单词b，那么定义b是a的Anigram，例如单词army和mary互为Anigram。现在给定一个字典，输入Q个单词，从给出的字典中找出这些单词的Anigram。

Input第1行：1个数N，表示字典中单词的数量。(1 <= N <= 10000)
第2 - N + 1行，字典中的单词，单词长度 <= 10。
第N + 2行：查询的数量Q。(1 <= Q <= 10000)
第N + 3 - N + Q - 2行：用作查询的单词，单词长度 <= 10。Output共Q行，输出Anigram的数量，相同的2个单词不算Anigram，如果没有输出0。Sample Input

5

add

dad

bad

cad

did

3

add

cac

dda

Sample Output

/*

    首先定义a-z分别为从1开始的素数,例如a=2,b=3,c=5,d=7这样.

    然后定义一个函数int Func(char* data)

    然后函数里面对于每个单词的每个字母进行相乘,例如单词abc就等于5*2*3=30;返回30

    然后再到字典里面去找与这个单词位数相同且Func返回值相同的单词就好了.

    这个算法主要用到了一个数学界的定理,如果一个正整数是n个素数相乘的结果,那么这个正整数有且只有一组素数解.

    定理证明过程

    z = a1*a2*....*an.

    用反证法,如果有解,那么

    z = a1*a2*.....*an-2*b*c,(b c代表如果有其它解的情况)两式相除得到下面的

    对于这个题来说，还要将答案减去字典中与该字符串相等的字符串个数

*/

#include<iostream>

#include<cstdio>

#include<cstring>

#include<map>

using namespace std;

int su[],cnt,n;

map<string,int>q1;

map<long long,int>q2;

bool vis[];

int main(){

    scanf("%d",&n);

    for(int i=;i<=;i++){

        if(!vis[i])su[++cnt]=i;

        for(int j=;j<=cnt&&su[j]*i<=;j++){

            vis[su[j]*i]=;

            if(i%su[j]==)break;

        }

    }

    long long ans=;

    string s;

    for(int i=;i<=n;i++){

        cin>>s;

        q1[s]++;

        int len=s.length();

        long long num=;

        for(int j=;j<len;j++){

            int x=s[j]-'a'+;

            num*=x;

        }

        q2[num]++;

    }

    scanf("%d",&n);

    for(int i=;i<=n;i++){

        cin>>s;

        int ans=;

        int len=s.length();

        long long num=;

        for(int j=;j<len;j++){

            int x=s[j]-'a'+;

            num*=x;

        }

        ans=q2[num]-q1[s];

        printf("%d\n",ans);

    }

}

AC代码唯一分解定理

I - 全排列（搜索）

给出一个字符串S（可能有重复的字符），按照字典序从小到大，输出S包括的字符组成的所有排列。例如：S = "1312"，

输出为：

1123

1132

1213

1231

1312

1321

2113

2131

2311

3112

3121

3211

Input输入一个字符串S（S的长度 <= 9，且只包括0 - 9的阿拉伯数字）Output输出S所包含的字符组成的所有排列Sample Input

Sample Output

#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<map>

#define maxn 10

using namespace std;

int q[maxn],n,a[maxn];

char s[maxn];

bool vis[maxn];

map<string,int>v;

void dfs(int pos){

    if(pos==n+){

        string c="";

        for(int i=;i<=n;i++)c+=a[i]+'';

        if(v[c])return;

        v[c]=;

        for(int i=;i<=n;i++)printf("%d",a[i]);

        puts("");

        return;

    }

    for(int i=;i<=n;i++){

        if(!vis[i]){

            vis[i]=;

            a[pos]=q[i];

            dfs(pos+);

            vis[i]=;

        }

    }

}

int main(){

    scanf("%s",s+);

    n=strlen(s+);

    for(int i=;i<=n;i++)q[i]=s[i]-'';

    sort(q+,q+n+);

    dfs();

}

75分暴力

#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cstring>

using namespace std;

int a[],n;

char s[];

int main(){

    scanf("%s",s);

    n=strlen(s);

    for(int i=;i<n;i++)a[i]=s[i]-'';

    sort(a,a+n);

    do{

        for(int i=;i<n;i++)cout<<a[i];

        cout<<endl;

    }while(next_permutation(a,a+n));

}

100分 next_permutation

J - 旋转字符串（STL）

S[0...n-1]是一个长度为n的字符串，定义旋转函数Left(S)=S[1…n-1]+S[0].比如S=”abcd”,Left(S)=”bcda”.一个串是对串当且仅当这个串长度为偶数，前半段和后半段一样。比如”abcabc”是对串,”aabbcc”则不是。

现在问题是给定一个字符串，判断他是否可以由一个对串旋转任意次得到。

Input第1行：给出一个字符串（字符串非空串，只包含小写字母，长度不超过1000000）Output对于每个测试用例，输出结果占一行，如果能，输出YES，否则输出NO。Sample Input

aa

ab

Sample Output

YES

NO

/*

    对串无论旋转多少次都是对串，所以直接判断当前字符串是否是对串即可

*/

#include<iostream>

#include<cstring>

#include<cstdio>

using namespace std;

string s;

int main(){

    while(cin>>s){

        int l=s.length();

        if(l%!=){

            puts("NO");

            continue;

        }

        l/=;

        string s1=s.substr(,l);

        string s2=s.substr(l,l);

        if(s1==s2)puts("YES");

        else puts("NO");

    }

    return ;

}

100分

K - 畅通工程（Tarjan）

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？

Input测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。
注意:两个城市之间可以有多条道路相通,也就是说
3 3
1 2
1 2
2 1
这种输入也是合法的
当N为0时，输入结束，该用例不被处理。
Output对每个测试用例，在1行里输出最少还需要建设的道路数目。
Sample Input

Sample Output

/*

    答案=强联通分量个数-1

*/

#include<iostream>

#include<cstdio>

#include<cstring>

#define maxn 1010

#define min(a,b) (a)<(b)?(a):(b)

using namespace std;

int n,m,num,head[maxn];

struct node{

    int to,pre;

}e[maxn*maxn];

void Insert(int from,int to){

    e[++num].to=to;

    e[num].pre=head[from];

    head[from]=num;

}

int dfn[maxn],low[maxn],st[maxn],top,cnt;

bool in[maxn];

bool Tarjan(int u){

    cnt++;dfn[u]=low[u]=cnt;st[++top]=u;in[u]=;

    for(int i=head[u];i;i=e[i].pre){

        int v=e[i].to;

        if(!dfn[v]){

            Tarjan(v);

            low[u]=min(low[u],low[v]);

        }

        else if(in[v])low[u]=min(low[u],dfn[v]);

    }

    if(dfn[u]==low[u]){

        while(st[top]!=u){

            in[st[top]]=;

            top--;

        }

        in[u]=;

        top--;

    }

}

int main(){

    while(){

        memset(in,,sizeof(in));

        memset(dfn,,sizeof(dfn));

        memset(low,,sizeof(low));

        memset(head,,sizeof(head));

        memset(e,,sizeof(e));

        num=;cnt=;

        scanf("%d",&n);

        if(n==)return ;

        scanf("%d",&m);

        int x,y;

        for(int i=;i<=m;i++){

            scanf("%d%d",&x,&y);

            Insert(x,y);Insert(y,x);

        }

        int sum=;

        for(int i=;i<=n;i++){

            if(!dfn[i]){

                sum++;

                Tarjan(i);

            }

        }

        printf("%d\n",sum-);

    }

}

100分 Tarjan