Good Bye 2014 A,B,C,D,E

A. New Year Transportation

题目链接：codeforces.com/contest/500/problem/A

题意： 给你一张图，问你能不能从起点出发到达指定的另外一点，另外这个图是一个DAG图（有向无环图），并且每个点只能连一条边。

做法：就是不断的迭代，如果当前点的编号大于指定点的话则证明失败，如果等于的话证明成功，如果小于的话则继续再进行迭代。

code:

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <cstring>
#define inf 10000000

using namespace std;

const int maxn=50500;
const int maxe=100000;

int a[maxn];

int main()
{
    int n,t,pos;
    scanf("%d%d",&n,&t);
    for(int i=1;i<n;i++) scanf("%d",&a[i]);
    pos=1;
    bool res;
    while(1){
        if(pos==t){
            res=true;
            break;
        }
        else if(pos>t){
            res=false;
            break;
        }
        else pos=pos+a[pos];
    }
    if(res) printf("YES\n");
    else printf("NO\n");
    return 0;
}

B. New Year Permutation

题目链接：http://codeforces.com/contest/500/problem/B

题意：给你一个序列，再给你一个矩阵，aij=1 表示序列中的第i个元素可以和第j个元素进行交换，不限交换次数，问给定序列通过交换所能得到的字典序最小的序列是什么。

思路：如果a可以和b交换，b可以和c交换，则a就可以和c交换，（这其实就是一个关系的闭包），所以我们先要将这些关系合并起来，得到一个能够互相交换的位置的集合，（这个地方的做法有很多，可以用并查集，floyd，也可以用离散上求关系闭包的算法），之后对于每个集合，我们降其中的数和位置都按升序的方式排序，将较小的数放在靠前的位置上即可。

code：

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <cstring>
#define inf 10000000

using namespace std;

const int maxn=305;
const int maxe=100000;

int a[maxn],b[maxn];
int c[maxn],p[maxn];
bool vis[maxn];
int cc[maxn][maxn];
char tt[maxn];

int par[maxn],high[maxn];

void init(int n)
{
    for(int i=0;i<=n;i++){
        par[i]=i;
        high[i]=0;
    }
}
int Find(int x)
{
    if(par[x]==x) return x;
    else return par[x]=Find(par[x]);
}
void unite(int x,int y)
{
    x=Find(x);
    y=Find(y);
    if(x==y) return ;
    if(high[x]<high[y]) par[x]=y;
    else{
        par[y]=x;
        if(high[x]==high[y]) high[x]++;
    }
}
bool same(int x,int y)
{
    return Find(x)==Find(y);
}
int main()
{
    int n,ta;
    scanf("%d",&n);
    init(n);
    memset(cc,0,sizeof(cc));
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    for(int i=0;i<n;i++){
        scanf("%s",tt);
        for(int j=0;j<n;j++) if(tt[j]=='1') cc[i][j]=1;
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(cc[i][j]) unite(i,j);
        }
    }
    memset(vis,0,sizeof(vis));
    for(int i=0;i<n;i++){
        if(vis[i]) continue;
        ta=0;
        p[ta]=i;
        c[ta++]=a[i];
        vis[i]=1;
        for(int j=0;j<n;j++){
            if(i==j||vis[j]) continue;
            if(same(i,j)){
                p[ta]=j;
                c[ta++]=a[j];
                vis[j]=1;
            }
        }
        sort(c,c+ta);
        sort(p,p+ta);
        for(int i=0;i<ta;i++) b[p[i]]=c[i];
    }
    for(int i=0;i<n;i++) printf("%d%c",b[i],i==n-1? '\n':' ');
    return 0;
}

C. New Year Book Reading

题目链接：http://codeforces.com/contest/500/problem/C

题意：给你一摞书，然后给出一个阅读计划（第i天读第j本书），读第j本书时，需要降第j本书上面的所有的书籍取出来，然后再放进去，然后将看完的书放在最上面，每本数都有个重量，每次看书时所付出的代价，就是取书时的重量和，给定了阅读计划，问如何排一开始序列的顺序使总的代价最小。

做法：就是贪心的按照书的出现顺序来确定一开始书的顺序，这样做的依据是假设在第j天第i本书才第一次看到，拿第i本数肯定要放在第j天所有看过的数的前面，这样的话在j天前第i本书就不会产生代价。

code：

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <cstring>
#define inf 10000000

using namespace std;

const int maxn=600;
const int maxm=1500;
const int maxe=100000;

int w[maxn],r[maxm],p[maxn];
bool vis[maxn];

int main()
{
    int n,m,res,pos,mid;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++) scanf("%d",&w[i]);
    for(int i=0;i<m;i++){
      scanf("%d",&r[i]);
      r[i]--;
    }
    memset(vis,0,sizeof(vis));
    for(int i=0;i<n;i++) p[i]=i;
    for(int i=n-1;i>=0;i--){
        for(int j=0;j<m;j++){
            if(vis[r[j]]) continue;
            p[i]=r[j];
            vis[r[j]]=1;
            break;
        }
    }
    res=0;
    for(int j=0;j<m;j++){
        mid=0;
        for(int i=n-1;i>=0;i--){
            if(p[i]==r[j]){
                pos=i;
                break;
            }
            else mid+=w[p[i]];
        }
        res+=mid;
        p[n]=p[pos];
        for(int i=pos+1;i<=n;i++) p[i-1]=p[i];
    }
    printf("%d\n",res);
    return 0;
}

D. New Year Santa Network

题目链接：http://codeforces.com/contest/500/problem/D

题意：给你一棵树，再给出一种操作，就是将树上的一条边的权值减小，每次操作后要输出一个期望，这个期望是从树上任取三点a，b，c，他们的距离和（d（a,b）+d(a,c)+d(b,c)）。

思路：期望的求法是所有组合的和/总的组合的个数，但是要怎么求整棵树所有组合的和呢？？？ 我们可以这样来想，从计算每条边在算和的时候用了多少次这个角度出发来算这个和，因为所给出的是一棵树，所以将树上的一条边拆掉之后树就被分成了两个集团（假设分成了A,B两个集团），设这两个集团的结点的个数分别为na和nb，则这条边能够形成的方案数为(C(x,y)表示从x中选y个的方案数)   C(na,2)*C(nb,1)+C(na,1)*C(nb,2)，且每种方案这条边都要用两次，这样的话我们就能知道每条边所贡献的和了。 之后先算出来一个总和，然后每次修改的时候将和改一下就好了。

ps：  中间的计算过程不能用和，要直接用期望来算，用和的话会暴long long～～～～

code：

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cstring>

using namespace std;

typedef long long LL;

const  int maxn=300500;

struct edge
{
    int to,next;
    LL cc;
} P[maxn];

int head[maxn],si;
int fa[maxn];
LL num[maxn],V,nn;

void add_edge(int s,int t,LL c)
{
    P[si].to=t;
    P[si].cc=c;
    P[si].next=head[s];
    head[s]=si++;
}

void dfs(int v,int f)
{
    num[v]=1;
    fa[v]=f;
    for(int i=head[v];i!=-1;i=P[i].next){
        int u=P[i].to;
        if(u==f) continue;
        dfs(u,v);
        num[v]+=num[u];
    }
}

double solve()
{
    LL n1,n2;
    double sum;
    int u;
    sum=0.0;
    dfs(1,-1);
    for(int i=0;i<si;i+=2){
        if(fa[P[i].to]==P[i^1].to) u=P[i].to;
        else u=P[i^1].to;
        n1=num[1]-num[u];
        n2=num[u];
        if(n1>=2) sum+=(double)((n1*(n1-1))*n2*P[i].cc)/nn;
        if(n2>=2) sum+=(double)((n2*(n2-1))*n1*P[i].cc)/nn;
    }
    return sum;
}

int main()
{
    int s,T,u;
    LL n1,n2,c,t;
    double sum;
    memset(head,-1,sizeof(head));
    memset(num,0,sizeof(num));
    memset(fa,-1,sizeof(fa));
    si=0;
    scanf("%lld",&V);
    nn=(V*(V-1)*(V-2))/6;
    for(int i=1;i<V;i++){
        scanf("%d%d%lld",&s,&t,&c);
        add_edge(s,t,c);
        add_edge(t,s,c);
    }
    sum=solve();
    scanf("%d",&T);
    while(T--){
        scanf("%d%lld",&s,&t);
        s=(s-1)*2;
        if(fa[P[s].to]==P[s^1].to) u=P[s].to;
        else u=P[s^1].to;
        n1=num[1]-num[u];
        n2=num[u];
        if(n1>=2) sum-=(double)((n1*(n1-1))*n2*(P[s].cc-t))/nn;
        if(n2>=2) sum-=(double)((n2*(n2-1))*n1*(P[s].cc-t))/nn;
        P[s].cc=t;
        P[s^1].cc=t;
        printf("%f\n",sum);
    }
    return 0;
}

E.  New Year Domino

題意：給你一個多米諾骨牌的序列，序列中的每个元素包含两个参数：位置和高度。 之后再给出一系列的查询，每个查询包含两个参数x和y。 表示为推动第x个骨牌，x～y其中的所有骨牌都倒下的最小代价是多少，代价的意思是现在推动一个骨牌，因为其过矮，可能不会使任何的骨牌倒下，这个时候就需要增加这个骨牌的高度，其所增加的高度就是消耗的代价，代价的增长是以1为单位的，所有的高度和位置也都是整数。

思路：

首先预处理出来将第i个骨牌及其后面全部推倒的最小花费，然后对于每个询问假设其查询的区间为（x，y）则有   cost[x][y]=cc[x]-cc[k]，其中cc[i]表示将i及其后面的元素全部推倒所需要的最小花费，k为x～y中所能达到的最右的那个骨牌（就是p[i]+h[i]值最大的那个骨牌）。

下面再介绍一下预处理的优化：

cc[i]表示第i个位置的最小值，它所能达到的距离为r[i]，再求cc[i]的时候我们先要通过二分查找找到位置大于r[i]的第一个元素，设这个元素为pos，则有

cc[i]=min(cc[k] (i<k<pos),cc[pos]+p[pos]-r[i])  这个方程应该是很好理解的吧，就是第i个元素推动其他元素有两种途径：第一种，是通过推倒它范围内的其他元素来实现。 第二种，是通过增加高度，推倒它最大范围之外的第一个元素来实现。

其中cc[k] 可以维护通过维护一个单点更新区间查询的线段树就能将这个过程加快。

整体的复杂度为o(nlogn).

code:

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#define INF 1000000000

using namespace std;

const int maxn=200200;

int flog[maxn<<1];
int d[maxn][30];
int cc[maxn];
int h[maxn],p[maxn],r[maxn];
int n,q,len,dat[maxn<<2];

void seg_init(int n_)
{
    len=1;
    while(len<n_) len*=2;
    for(int i=0;i<2*len-1;i++) dat[i]=INF;
}
void update(int k,int a)
{
    k+=len-1;
    dat[k]=a;
    while(k>0){
        k=(k-1)>>1;
        dat[k]=min(dat[(k<<1)+1],dat[(k<<1)+2]);
    }
}
int query(int a,int b,int k,int l,int r)
{
    if(l>b||r<a) return INF;
    else if(a<=l&&r<=b) return dat[k];
    else{
        int v1,v2;
        v1=query(a,b,(k<<1)+1,l,(l+r)/2);
        v2=query(a,b,(k<<1)+2,(l+r)/2+1,r);
        return min(v1,v2);
    }
}

void RMQ_init(const int A[])
{
    for(int i=0;i<n;i++) d[i][0]=i;
    for(int j=1;(1<<j)<=n;j++)
        for(int i=0;i+(1<<j)-1<n;i++){
            int m1=d[i][j-1],m2=d[i+(1<<(j-1))][j-1];
            if(A[m1]>A[m2]) d[i][j]=m1;
            else d[i][j]=m2;
        }
}
int RMQ(int L,int R)
{
    int k=flog[R-L+1];
    int m1=d[L][k],m2=d[R-(1<<k)+1][k];
    if(r[m1]>r[m2]) return m1;
    else return m2;
}

int main()
{
    //freopen("input.txt","r",stdin);
    flog[0]=-1;
    for(int i=1;i<2*maxn;i++) flog[i]=flog[i>>1]+1;
    int st,ed,x,pos;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d %d",&p[i],&h[i]);
        p[i]--;
        r[i]=p[i]+h[i];
    }
    seg_init(n);
    RMQ_init(r);
    cc[n-1]=0;
    update(n-1,0);
    for(int i=n-2;i>=0;i--){
        pos=upper_bound(p+i,p+n,r[i])-p;
        if(pos==n) cc[i]=0;
        else if(pos==i+1) cc[i]=cc[i+1]+p[i+1]-r[i];
        else{
            cc[i]=query(i,pos-1,0,0,len-1);
            cc[i]=min(cc[i],cc[pos]+p[pos]-r[i]);
        }
        update(i,cc[i]);
    }
    //for(int i=0;i<n;i++) printf("%d%c",cc[i],i==n-1? '\n':' ');
    scanf("%d",&q);
    while(q--){
        scanf("%d%d",&st,&ed);
        st--; ed--;
        x=RMQ(st,ed);
        printf("%d\n",cc[st]-cc[x]);
    }
    return 0;
}