2016"百度之星" - 初赛（Astar Round2A）

http://acm.hdu.edu.cn/showproblem.php?pid=5692

 

题意:给一棵树,点有权值. 操作1:询问从0点出发,经过x点(输入)的路径中,点权和最大的路径的和是多少. 操作2:将x号点的值更新为y.

 

思路:已0为根形成一个有根树,经过x点的所有路径的终点都在已x为根的子树中,问题相当于求一颗子树中的所有节点到0点的距离最大值,将题目的点权理解成距离.

 

解法:用dfs顺序对0为根的树标号,按照标号作为线段树的序号,那么某一颗子树的点在线段树的区间也是连续的了,这是一个常见的做法,参见线段树专题的树标号.

然后bfs,dfs都可以,处理出初始每个点作为终点到0点的路径和. 简单的累加. 线段树维护的是以0为起点 x为终点的路径和数组.

对于查询操作,就是线段树最大值查询.  对于更新操作, 变化量 delta= now - pre ,  如果一个点值变大delta ,那么以该点为根的子树, 每个点的路径和都会增加这么多,线段树区间更新 +delta.

 

//#define debug
#include<cstdio>
#include<cstdlib>
#include<vector>
#define lrrt int L,int R,int rt
#define iall 1,n,1
#define imid int mid=(L+R)>>1
#define lson L,mid,rt<<1
#define rson mid+1,R,rt<<1|1
using namespace std;
typedef long long LL;
const LL inf=0x3f3f3f3f3f3f3f3fLL;
const int M=1e5+10;
int n,m;
struct E{
    int u,v;
}e[M];
struct Q{
    int type,x;
    LL y;
}q[M];
int a[M];
vector<LL> answer;
vector<int> g[M];
struct N{
    int l,r;
}node[M];
LL dist[M];
int Index;
struct T{
    LL value,lazy;
}tree[M<<2];
void init(){
    for(int i=0;i<n;i++){
        g[i].clear();
    }
    for(int i=0;i<n-1;i++){
        int u=e[i].u;
        int v=e[i].v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
}
void dfs(int u,int fa){
    node[u].l=++Index;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==fa) continue;
        dfs(v,u);
    }
    node[u].r=Index;
}
void dfs_for_dist(int u,int fa){
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==fa) continue;
        dist[v]+=dist[u];
        dfs_for_dist(v,u);
    }
}
void build(lrrt){
    tree[rt].value=0;
    tree[rt].lazy=0;
    if(L==R) return ;
    imid;
    build(lson);
    build(rson);
}
void pushup(int rt){
    tree[rt].value=max(tree[rt<<1].value,tree[rt<<1|1].value);
}
void pushdown(int rt){
    LL &z=tree[rt].lazy;
    if(z!=0){
        tree[rt<<1].lazy+=z;
        tree[rt<<1|1].lazy+=z;
        tree[rt<<1].value+=z;
        tree[rt<<1|1].value+=z;
        z=0;
    }
}
void update(int x,int y,LL z,lrrt){
    if(x<=L&&R<=y){
        tree[rt].value+=z;
        tree[rt].lazy+=z;
        return ;
    }
    imid;
    pushdown(rt);
    if(mid>=x) update(x,y,z,lson);
    if(mid<y)  update(x,y,z,rson);
    pushup(rt);
}
LL query(int x,int y,lrrt){
    if(x<=L&&R<=y) return tree[rt].value;
    imid;
    pushdown(rt);
    LL big=-inf;
    if(mid>=x) big=max(big,query(x,y,lson));
    if(mid<y)  big=max(big,query(x,y,rson));
    return big;
}
void solve(){
    init();
    Index=0;
    dfs(0,-1);
    for(int i=0;i<n;i++){
        dist[i]=a[i];
    }
    dfs_for_dist(0,-1);
    build(iall);
    for(int i=0;i<n;i++){
        #ifdef debug
        printf("i=%d  l=%d  r=%d\n",i,node[i].l,node[i].r);
        #endif // debug
        update(node[i].l,node[i].l,dist[i],iall);
    }
    answer.clear();
    for(int i=0;i<m;i++){
        if(q[i].type){
            int u=q[i].x;
            answer.push_back(query(node[u].l,node[u].r,iall));
        }
        else{
            int u=q[i].x;
            LL d=q[i].y-a[u];
            a[u]=q[i].y;
            update(node[u].l,node[u].r,d,iall);
        }
    }
}
int main(){
    int t;
    while(~scanf("%d",&t)){
        int cas=1;
        while(t--){
            scanf("%d%d",&n,&m);
            for(int i=0;i<n-1;i++){
                scanf("%d%d",&e[i].u,&e[i].v);
            }
            for(int i=0;i<n;i++){
                scanf("%d",&a[i]);
            }
            for(int i=0;i<m;i++){
                scanf("%d%d",&q[i].type,&q[i].x);
                if(q[i].type==0){
                    scanf("%I64d",&q[i].y);
                }
            }
            solve();
            printf("Case #%d:\n",cas++);
            for(int i=0;i<answer.size();i++){
                printf("%I64d\n",answer[i]);
            }
        }
    }
    return 0;
}

 

 

 

http://acm.hdu.edu.cn/showproblem.php?pid=5695

 

题意：n个人排队 ，给出m对点，表示u 不希望 v 排在自己前面， 每个人的得分是前面包括自己在内id的最小值。求一个排列，满足要求，且总分最高。

 

解法：u-》v建一条有向边 ，拓扑排序的结果就是一个合法的解。要使得总分高，那么当有多个可以排队的情况下，贪心选取id大的先排会使得得分大。

 

#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
typedef long long LL;
const int M=1e5+10;
int t,n,m;
struct E{
    int u,v;
}e[M];
int d[M];
int answer[M];
vector<int> g[M];
priority_queue<int> q;
void init(){
    for(int i=1;i<=n;i++){
        d[i]=0;
        g[i].clear();
    }
    for(int i=0;i<m;i++){
        g[e[i].u].push_back(e[i].v);
        d[e[i].v]++;
    }
}
LL solve(){
    init();
    while(!q.empty()) q.pop();
    for(int i=1;i<=n;i++){
        if(!d[i]){
            q.push(i);
        }
    }
    int la=0;
    while(!q.empty()){
        int u=q.top();
        q.pop();
        answer[la++]=u;
        for(int i=0;i<g[u].size();i++){
            int v=g[u][i];
            d[v]--;
            if(!d[v]){
                q.push(v);
            }
        }
    }
    LL sum=0;
    int small=n+1;
    for(int i=0;i<n;i++){
        small=min(small,answer[i]);
        sum+=small;
    }
    return sum;
}
int main(){
    while(~scanf("%d",&t)){
        while(t--){
            scanf("%d%d",&n,&m);
            for(int i=0;i<m;i++){
                scanf("%d%d",&e[i].u,&e[i].v);
            }
            printf("%lld\n",solve());
        }
    }
    return 0;
}

 

 

 

end