2015-2016 ACM-ICPC Nordic Collegiate Programming Contest (NCPC 2015)

题目链接 ：  http://codeforces.com/gym/100781/attachments

A-Adjoin the Network

题意大概是有多棵树(也可能是一颗)，现在要把它们合并成一颗树，且保证最终这棵树的最远点对最小，求最后的这棵树的最长链(最远点对)的长度。

练习赛时想的是我们在每棵树上跑出最长链，并找到中间点，然后以所有"最长链"中的最长链的中间点为根节点，其他"最长链"的中间点直接与这个根节点相连即可构造出最远点对最小的大树。然而并不知道怎么找到最长链的中间点，跑最长链也有点不熟。

其实这题只要有上面构造的思路，然后求出所有最长链的长度即可。因为最后这棵最远点对最小的大树其最长链的只可能有三种情况(对应三种推出方式):

1. 最长链的长度

2. 最长链的"一半"长度 + 次长链的"一半"长度 + 1

3. 次长链的"一半"长度 + 季长链的"一半"长度 + 1

ps : 以上的"一半"是偶取半，奇取半+1 这个画下图就能明白

然后我们只需要跑出每棵小树的"最长链"长度排序计算即可。

 #include <bits/stdc++.h>
 using namespace std;
 #define pb(x) push_back((x));

 const int INF=0x3f3f3f3f;
 vector< int > G[+];
 bool vis[+];
 int d[+][];
 vector< int > lian;
 int longest;

 void dfs1(int me, int fa){
     vis[me]=true;
     for(auto son:G[me]){
         if(son==fa)    continue;
         dfs1(son,me);
         if(d[son][]+>=d[me][]){
             d[me][]=d[me][];
             d[me][]=d[son][]+;
         }
     }
 }

 void dfs2(int me ,int fa){
     if(fa!=-){
         if(d[me][]+==d[fa][]) d[me][]=max(d[me][]+d[me][],d[me][]++d[fa][]);
         else d[me][]=max(d[me][]+d[me][],d[me][]++d[fa][]);
     }
     else{
         d[me][]=d[me][]+d[me][];
     }
     for(auto son: G[me]){
         if(son==fa)    continue;
         dfs2(son,me);
     }
     longest=max(longest,d[me][]);
 }

 bool cmp(int a,int b){
     return a>b;
 }

 int getR(int L){
     if(L%) return L/+;
     return L/;
 }

 int main(){
     int N,M;
     scanf("%d%d",&N,&M);
     for(int i=;i<N;++i) {
         G[i].clear();
         vis[i]=false;
     }
     lian.clear();
     for(int i=;i<M;++i){
         int u,v;
         scanf("%d%d",&u,&v);
         G[u].pb(v);
         G[v].pb(u);
     }
     for(int i=;i<N;++i){
         if(vis[i]==false){
             longest=-;
             dfs1(i,-);
             //printf("%d : %d\n",i,d[i][0]+d[i][1]);
             dfs2(i,-);
             lian.pb(longest);
         }
     }
     sort(lian.begin(),lian.end(),cmp);
     int ans=-;
     if(lian.size()>) ans=max(ans,lian[]);
     if(lian.size()>) ans=max(ans,getR(lian[])+getR(lian[])+);
     if(lian.size()>) ans=max(ans,getR(lian[])+getR(lian[])+);
     printf("%d\n",ans);
     return ;
 }

开始的时候只用一次dfs跑，这只能跑出根节点的最长链，还要第二次dfs。 简单说明: d[i][0]为i点固定方法最深度 ,d[i][1]为次深度,d[i][2]为经过i点的最长链长度。

(求最远点对的方法以前学过，这题应该很快写出来才是，惭愧惭愧。

E-Entertainment Box

最开始学贪心的例子是给出一系列课程(知道开始与结束时间)，需要尽可能安排上更多的课程，解决方案是贪心结束时间早的。

而这道题相当于给了N个时间段，K个轨道可以跑时间段，要求能上最多的课程数。(题目是录节目，我说成上课，其实一个意思)

想法还是贪心结束时间靠前的，用一个数据结构模拟K个轨道跑课程。

错误代码:

 #include<bits/stdc++.h>
 using namespace std;
 #define fst first
 #define scd second

 typedef long long ll;
 typedef pair<ll , ll > pii;
 queue< pii > Q;
 pii pro[+];
 int _id[+];

 bool cmp(int i,int j){
     if(pro[i].scd!=pro[j].scd)return pro[i].scd<pro[j].scd;
     return pro[i].fst<pro[i].fst;
 }

 int main(){
     int N,K;
     while(~scanf("%d%d",&N,&K)){
     //printf("N K :%d %d\n",N,K);
     for(int i=;i<=N;++i){
         ll xx,yy;
         scanf("%lld%lld",&xx,&yy);
         _id[i]=i;
         pro[i]=make_pair(xx,yy);
     }
     sort(_id+,_id++N,cmp);
     while(!Q.empty()) Q.pop();
     //for(int i=1;i<=N;++i) printf("record %d : %lld %lld\n",i,pro[_id[i]].fst,pro[_id[i]].scd);
     int cnt=;
     for(int i=;i<=K;++i) Q.push(make_pair(-1ll,0ll));
     //printf("N K :%d %d\n",N,K);
     for(int i=;i<=N;++i){
         pii can=pro[_id[i]];
         while((!Q.empty())&&can.fst>=Q.front().scd) Q.pop();
         if(Q.size()<K){
             Q.push(can);
             //printf("record %d : %lld %lld\n",i,pro[_id[i]].fst,pro[_id[i]].scd);
             cnt++;
         }
     }
     printf("%d\n",cnt);
 }
     return ;
 }

插入新课程时队列会弹出所有已经早于新课程开始时间就结束的课程，然而这是不行的。

如

5 3

1 2

1 3

1 5

4 6

1 7

这是队友出的Hack数据，如果(4  6) 入队 ，(1  2) 和(1  3)都会被弹出，然后 (1, 7)  反而可以被多计一次了。

正确更换课程应该最多更换一个早于新课程开始时间就结束的且最近的课程。这时候我们需要用 multiset 。(之前队列不行也可以理解为我们已经贪结束时间了，不能随便按自然时间流逝弹出所有早于新课程开始时间就结束的课程)

AC代码:

 #include <bits/stdc++.h>
 using namespace std;
 #define fst first
 #define scd second
 typedef pair<int ,int > pii;
 multiset <int > mtst;

 bool cmp(pii a, pii b){
     if(a.scd!=b.scd) return a.scd<b.scd;
     return a.fst<b.fst;
 }

 pii P[+];

 int main(){
     int N,K;
     scanf("%d%d",&N,&K);
     for(int i=;i<N;++i){
         scanf("%d%d",&P[i].fst,&P[i].scd);
         //printf("%d : %d %d\n",i,P[i].fst,P[i].scd);
     }
     sort(P,P+N,cmp);
     //for(int i=0;i<N;++i) printf("%d : %d %d\n",i,P[i].fst,P[i].scd);
     for(int i=;i<K;++i){
         mtst.insert();
     }
     multiset< int > :: iterator p;
     int cnt=;
     for(int i=;i<N;++i){
         int l=P[i].fst,r=P[i].scd;
         p=mtst.upper_bound(l);
         if(p==mtst.begin()) continue;
         p--;
         mtst.erase(p);
         mtst.insert(r);
         //printf("r : %d\n",r);
         cnt++;
     }
     printf("%d\n",cnt);
     return ;
 }