2016CCPC东北地区大学生程序设计竞赛【01/03/05/06/08】

吧啦啦啦啦啦啦啦啦啦啦啦能量，ACM，跨！变身！变成一个智障！

04正在酝酿中！！！马上更新！！！！！

 01题意：有一个n个点的图，对于任意两个不同的点，他的权值是两个点下标的最小公倍数，求最小生出树。

思路：最小生成树就是1到各个点，ans=n*(n+1)/2-1;

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAX=1000010;
LL n,m;
int main()
{
    int t,i,j;
    int cas=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%lld",&n);
        LL sum=0;
        sum=n*(n+1)/2-1;
        printf("Case #%d: ",cas++);
        printf("%lld\n",sum);
    }
    return 0;
}

 03题意：给你两个整数A,B,求多少对(C,D)满足A/B+B/A<=C/D+D/C;A≤C≤B,A≤D≤B

思路:满足条件的整数对(A,B)或(B,A).

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAX=1000010;
LL n,m;
int main()
{
    int t,i,j;
    int cas=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%lld%lld",&n,&m);
        printf("Case #%d:\n",cas++);
        if(n>m)
            swap(n,m);
        if(n==m)
        {
            printf("1\n");
            printf("%lld %lld\n",n,m);
        }
        else
        {
            printf("2\n");
            printf("%lld %lld\n",n,m);
            printf("%lld %lld\n",m,n);

        }
    }
    return 0;
}

05

题意：

连连看

就是四周两个相同就YES，然后里面的相邻相同也OK

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;

const int N=35;
int ma[N][N];
map<int,int>mp;
int dx[4]={0,0,-1,1};
int dy[4]={1,-1,0,0};
int a,b;

bool Judge(int x,int y)
{
    if(x<1||y<1||x>a||y>b)
        return 0;
    return 1;
}

int main()
{
    int T,cas=1;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&a,&b);
        for(int i=1;i<=a;i++)
            for(int j=1;j<=b;j++)
                scanf("%d",&ma[i][j]);

        printf("Case #%d: ",cas++);
        if(a==1&&b==1)
        {
            puts("No");
            continue;
        }
        int flag=0;
        mp.clear();
        for(int i=1;i<=a;i++)
        {
            for(int j=1;j<=b;j++)
            {
                for(int k=0;k<4;k++)
                {
                    int xx=i+dx[k];
                    int yy=j+dy[k];
                    if(Judge(xx,yy))
                    {
                        if(ma[i][j]==ma[xx][yy])
                        {
                            flag=1;
                            break;
                        }
                    }
                }
                if(flag)
                    break;
            }
            if(flag)
                break;
        }
        if(flag)
        {
            puts("Yes");
            continue;
        }
        for(int i=1;i<=a;i++)//1列
        {
            if(!mp[ma[i][1]])
                mp[ma[i][1]]=1;
            else
            {
                flag=1;
                break;
            }
        }
        if(flag)
        {
            puts("Yes");
            continue;
        }
        mp.clear();
        for(int i=1;i<=a;i++)   //b列
        {
            if(!mp[ma[i][b]])
                mp[ma[i][b]]=1;
            else
            {
                flag=1;
                break;
            }
        }
        if(flag)
        {
            puts("Yes");
            continue;
        }
        mp.clear();
        for(int i=1;i<=b;i++)       //1行
        {
            if(!mp[ma[1][i]])
                mp[ma[1][i]]=1;
            else
            {
                flag=1;
                break;
            }
        }
        if(flag)
        {
            puts("Yes");
            continue;
        }
        mp.clear();
        for(int i=1;i<=b;i++)//a行
        {
            if(!mp[ma[a][i]])
                mp[ma[a][i]]=1;
            else
            {
                flag=1;
                break;
            }
        }
        if(flag)
        {
            puts("Yes");
            continue;
        }
        puts("No");
    }
    return 0;
}

06：

定义集合里的点必须要满足

1 重要的点

2 是两个不同的重要的点的最近公共祖先

其中一个

然后每次询问给出不重要的点，问你集合最多几个点

思路：

对于LCA的操作其实就是对于这个结点，有两个子树里是重要点就一定是这两个结点的LCA了。

先预处理一下所有结点的关系，然后对于有两个出度的结点判断一下两个子树是否有重要的点就好了；

#include <bits/stdc++.h>
using namespace std;

const int N=1e5+10;

struct asd{
    int to;
    int next;
};
asd q[N*4];
int tol,head[N*4];
int pre[N];
int num[N],fei[N];
bool vis[N];
vector<int>pb;
int n,k;

void add(int a,int b)
{
    q[tol].to=b;
    q[tol].next=head[a];
    head[a]=tol++;
}

void init()
{
    tol=0;
    memset(head,-1,sizeof(head));
    for(int i=1;i<=n;i++)
    {
        fei[i]=0;
        num[i]=0;
        vis[i]=false;
    }
}

void dfs(int x)
{
    for(int v=head[x];v!=-1;v=q[v].next)
    {
        int to=q[v].to;
        if(vis[to]) continue;
        num[x]++;
        vis[to]=1;
        pre[to]=x;
        dfs(to);
    }
}

bool dfs_judge(int x)
{
    int sum=0;
    for(int v=head[x];v!=-1;v=q[v].next)
    {
        int to=q[v].to;
        if(pre[to]==x)
        {
            if(fei[to]!=k)
                return 1;
            else
            {
                if(dfs_judge(to))
                    return 1;
            }
        }
    }
    return 0;
}

int main()
{
    int T;
    int cas=1;
    scanf("%d",&T);
    while(T--)
    {
        int qq,a,b;
        int m;
        scanf("%d%d",&n,&qq);
        init();
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            add(a,b);
            add(b,a);
        }
        printf("Case #%d:\n",cas++);
        vis[1]=true;
        dfs(1);
        int ans;
        for(k=1;k<=qq;k++)
        {
            scanf("%d",&m);
            pb.clear();
            ans=n-m;
            while(m--)
            {
                int x;
                scanf("%d",&x);
                fei[x]=k;
                if(num[x]<2) continue;
                pb.push_back(x);
            }
            int sum;
            for(int i=0;i<pb.size();i++)
            {
                int u=pb[i];
                sum=0;
                for(int v=head[u];v!=-1;v=q[v].next)
                {
                    int to=q[v].to;
                    if(pre[to]!=u)
                        continue;
                    if(fei[to]!=k)
                        sum++;
                    else
                    {
                        if(dfs_judge(to))
                            sum++;
                    }
                    if(sum>=2)
                    {
                        ans++;
                        break;
                    }
                }
            }
            printf("%d\n",ans);
        }
    }
    return 0;
}

08：

 就是末位是0的话，如果这个栈不止1个元素  那答案一定是1，

 那么我们直接找离栈底最近的0就好了，0到栈底的那些1，运算答案和奇偶个数有关

用两个数组模拟正的到的，开一个flag模拟一下是哪个栈

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <map>
using namespace std;
#define LL long long
#define INF 0x3f3f3f3f
#define PI acos(-1.0)
#define E 2.71828
#define MOD 1000000007
#define N 200010
#define M 5010

int a[N*2];
int main()
{
    int T,cas = 1;
    scanf("%d",&T);
    while(T--)
    {
        memset(a,0,sizeof(a));
        int n;
        scanf("%d",&n);
        int num = 0;
        int l = n;
        int r = n-1;
        int i1 = -INF;
        int i2 = INF;
        int flag = 1;
        printf("Case #%d:\n",cas++);
        while(n--)
        {
            char s[10];
            scanf("%s",s);
            if(strcmp(s,"PUSH") == 0)
            {
                int x,i;
                scanf("%d",&x);
                if(flag)
                {
                    a[++r] = x;
                    i = r;
                }
                else
                {
                    a[--l] = x;
                    i = l;
                }
                if(x==0)
                {
                    i1 = max(i1,i);
                    i2 = min(i2,i);
                }
                num++;
            }
            else if(strcmp(s,"POP") == 0)
            {
                if(flag)
                    r--;
                else
                    l++;
                num--;
            }
            else if(strcmp(s,"QUERY") == 0)
            {
                if(num <= 0)
                {
                    puts("Invalid.");
                    continue;
                }
                if(i1==-INF && i2==INF)
                {
                    int len = r-l+1;
                    if(len&1)
                        puts("1");
                    else
                        puts("0");
                    continue;
                }
                if(num == 1)
                {
                    if(r != n-1)
                        printf("%d\n",a[r]);
                    else
                        printf("%d\n",a[l]);
                    continue;
                }
                if(flag)
                {
                    int ling = min(i1,i2);
                    int len = ling-l+1;
                    if(ling == r)
                        len--;
                    if(len&1)
                        puts("1");
                    else
                        puts("0");
                }
                else
                {
                    int ling = max(i1,i2);
                    int len = r-ling+1;
                    if(ling == l)
                        len--;
                    if(len&1)
                        puts("1");
                    else
                        puts("0");
                }
            }
            else
            {
                flag = !flag;
            }
        }
    }
    return 0;
}