2015 ACM/ICPC Asia Regional Changchun Online (部分)

1002.Ponds

这道题最纠结的是题意，到最后才弄明白原来是先去掉度数小于2的点，再在剩余图中找一些有奇数个点的连通块，将这些点的权值相加，求所有的符合条件的点的和。

首先是先将度数小于2的点标记，是用拓扑排序的思想，就是先找出所有度数小于2的点，放入队列，然后将与这些点相邻的点（即有边相连的点）度数减1,凡是度数小于2的点再放入队列，当然对于已标记的点不再重复进队列。

然后是找奇数点的块，从剩余的点中dfs搜索并记录这个点所在的块的点的数量同时先计算此连通块的权值，符合条件的，则加到最后的结果中，否则不加。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N=10005;
vector<int>G[N];//记录相邻的点
int v[N];
int du[N];
bool vis[N];
int p,m;
int c;
long long s;

bool dfs(int x)
{
    for(int i=0;i<G[x].size();i++)
    {
        int it=G[x][i];
        if(vis[it])
            continue;
        c++;
        s+=v[it];
        vis[it]=true;
        dfs(it);
    }
    if(c%2)
        return true;
     return false;
}

void work()
{
    queue<int>q;
    for(int i=1;i<=p;i++)
    {
        if(du[i]<2)
        {
            q.push(i);
            vis[i]=true;
        }
    }
    while(!q.empty())
    {
        int id=q.front();
        q.pop();
        for(int i=0;i<G[id].size();i++)
        {
            int it=G[id][i];
            du[it]--;
            if(vis[it])
            {
                continue;
            }
            if(du[it]<2)
            {
                q.push(it);
                vis[it]=true;
            }
        }
    }
    long long ans=0;
    for(int i=1;i<=p;i++)
    {
        if(vis[i])
            continue;
        c=0;s=0;
        if(dfs(i))
            ans+=s;
    }
    printf("%lld\n",ans);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&p,&m);
        for(int i=1;i<=p;i++)
        {
            scanf("%d",&v[i]);
            G[i].clear();
        }
        memset(vis,false,sizeof vis);
        memset(du,0,sizeof du);
        int x,y;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d",&x,&y);
            G[x].push_back(y);
            G[y].push_back(x);
            du[x]++;
            du[y]++;
        }
        work();
    }
}

1007.The Water Problem

线段树水题，不会先学线段树，这是找区间最大值

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1005;
int dat[4*N];
int a[N];
void build(int rt,int l,int r)
{
    if(l==r)
    {
        dat[rt]=a[l];
        return;
    }
    int m=(l+r)/2;
    build(rt*2,l,m);
    build(rt*2+1,m+1,r);
    dat[rt]=max(dat[rt*2],dat[rt*2+1]);
} 
int query(int rt,int l,int r,int ll,int rr)
{
    if(ll<=l && rr>=r)
    {
        return dat[rt];
    }
    int mid=(l+r)/2;
    int s1=0,s2=0;
    if(ll<=mid)    
       s1=query(rt*2,l,mid,ll,rr);
    if(rr>mid)
        s2=query(rt*2+1,mid+1,r,ll,rr);
    return s1>s2?s1:s2;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        memset(dat,0,sizeof dat);
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        build(1,1,n);
        int q,l,r;
        scanf("%d",&q);
        int ans=0;
        for(int i=0;i<q;i++)
        {
            scanf("%d%d",&l,&r);
            ans=query(1,1,n,l,r);
            printf("%d\n",ans);
        }
    }
}

1005.Travel

由于 n,m,q都比较大，所以一般的想法是离线做法，就是先把输入都输入，然后排序，因为这道题的问题的优化可以先排序，则为O（qn），而不优化的话是O（qn^2）,其实也可以再用一点小技巧再优化一下。
然后是用并查集将符合要求的集合统计出来(设为n)，推一下会发现这样的城市对数为n*(n-1)
小技巧为每次将两个集合合并(设x，y分别为两个集合的城市数)，推一下就会发现对于x的集合来说每加一个城市就会有加x中方案而又由于是可以双向的所以集合合并就加2xy。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
struct node
{
    int a,b,c;
    bool operator < (const node &p) const
    {
        return c<p.c;
    }
}r[200010];
struct node1
{
    int v,id;
    bool operator <(const node1 &p) const
    {
        return v<p.v;
    }
}x[50100];

int cnt[50010];
int f[200010];
int rak[200010];
int ss;
bool vis[200010];
int find1(int x) {
    return f[x] == x ? x : f[x] = find1(f[x]);
} 
void merge1(int i)
{
    ss=0;
    int xx=r[i].a;
    int yy=r[i].b;
    int x1=find1(xx);
    int y1=find1(yy);
    if(x1==y1)
        return;
    if(rak[x1]<rak[y1])
    {
      f[x1]=y1;
      rak[y1]+=rak[x1];
    }
    else
    {
        f[y1]=x1;
        rak[x1]+=rak[y1];
    }
    return ;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m,q;
        scanf("%d%d%d",&n,&m,&q);
        for(int i=1;i<=n;i++)
            f[i]=i;
        for(int i=0;i<m;i++)
            scanf("%d%d%d",&r[i].a,&r[i].b,&r[i].c);
        sort(r,r+m);
        for(int i=0;i<q;i++)
        {
            scanf("%d",&x[i].v);
            x[i].id=i;
        }
        sort(x,x+q);
        memset(cnt,0,sizeof cnt);
        int j=0,i=0;
        int sum=0,s1=0;
        fill(rak,rak+n+1,1);
        while(j<q)
        {
            while(r[i].c<=x[j].v && i<m)
            {
                merge1(i);
                i++;
            }
            for(int k=1;k<=n;k++)
            if(f[k]==k)
            {
                cnt[x[j].id]+=rak[f[k]]*(rak[f[k]]-1);
            }
            j++;
       }
        for(int i=0;i<q;i++)
            printf("%d\n",cnt[i]);
    }
    return 0;
}

1008.Elven Postman

其实一开始是想用二叉树做的,后来发现树的深度最坏的情况是1000,这样节点就太多了，所以后来用记忆化搜索做了一发，先把到达每一点的路径都保存起来，查询的时候直接输出，由于q并没有明确，所以觉得这样处理保险一点。

#include <cstdio>
#include <cstring>
#include <string>
#include <iostream>
using namespace std;
int a[1005];
string s[1005];
int n;
bool flag;
void query(int id,int x,int m,bool f)
{
    for(int i=id;i<=m;i++)
    {
        if(x==a[i])
        {
            s[x]+="\n";
            flag=true;
            return;
        }
        if(a[id]<=a[i] && f)
            continue;
        if(a[id]>=a[i]&&!f)
            continue;
        if(a[i]>x)
        {
            s[x]+="E";
            query(i,x,m,true);
            if(flag)
                return;
        }
        else if(a[i]<x)
        {
            s[x]+="W";
            query(i,x,m,false);
            if(flag)
                return;
        }
    }

}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            s[i].clear();
        }
       for(int i=1;i<=n;i++)
       {
           flag=false;
           if(i==1)
               s[a[i]]+="\n";
           else
           {
               if(a[i]>a[1])
               {
                   s[a[i]]+="W";
                   query(1,a[i],i,false);
               }
               else
               {
                   s[a[i]]+="E";
                   query(1,a[i],i,true);
               }
           }
       } 
       int q,d;
       scanf("%d",&q);
       for(int i=0;i<q;i++)
       {
           scanf("%d",&d);
           cout<<s[d];
       }
    }
}