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
;//记录相邻的点
int v
;
int du
;
bool vis
;
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
;
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];
}
}
}