CoderForces Round54 (A~E)

ProblemA Minimizing the String

题目链接

　　题解：这一题读完题就写了吧。就是让你删除一个字母，使得剩下的字符组成的字符串的字典序最小；我们只要第一个当前位置的字符比下一个字符小的位置把该字符删去即可；

　　参考代码：

 #include<bits/stdc++.h>
 using namespace std;
 #define PI acos(-1.0)
 #define RI register int
 #define clr(a,b) memset(a,b,sizeof a)
 typedef long long ll;
 const int INF=0x3f3f3f3f;
 const int maxn=2e5+;
 int n;
 char str[maxn];
 int main()
 {
     scanf("%d",&n);
     scanf("%s",str);
     int len=strlen(str),temp=len-;
     for(int i=;i<len-;++i)
     {
         if(str[i]-str[i+]>)
         {
             temp=i;
             break;
         }
     }
     for(int i=;i<len;++i) if(i!=temp) printf("%c",str[i]);
     printf("\n");
     return ;
 }

ProblemB  Divisor Subtraction

题目链接

　　题解：这一题就是让你找一个数的最小质因数，并减去它，一直循环，直到该数为零；考虑输入的数num,如果num为偶数，那么次数即为num/2(因为每次都是2)；对于一个奇数，它的第一个最小质因数一定是奇数，则经过一次循环后，num会变为偶数，回到了前面的情况；因此，只要分两种情况即可；

　　参考代码：

 #include <bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 ll N;
 int main()
 {
     cin>>N;
     for(ll i=;i*i<=N;++i) if(N%i==) { printf("%lld\n",(N-i)/+);return ; }
     puts("");
     return ;
 }

Problem C  Meme Problem

题目链接

　　题解：这一题数学公式推一下就行了Orz;

　　参考代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 #define clr(a,b) memset(a,b,sizeof a)
 int main()
 {
     double a,b,d;
     int t;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%lf",&d);
         double k=d*d-*d;
         if(<d&&d<) puts("N");
         else
         {
             a=(d+sqrt(k))/;
             b=(d-sqrt(k))/;
             printf("Y %.9f %.9f\n",a,b);
         }
     }
     return ;
 }

Problem D. Edge Deletion

题目链接

　　题解：给定 N 个点 M 条边的无向简单联通图，留下最多 K 条边，求剩下的点里面从 1 号顶点到其余各点最短路大小等于原先最短路大小的点最多怎么构造。这题用到贪心思想，我们可以在第一次跑 dij 时直接采用贪心策略，即：若当前答案集合的大小小于 K 且优先队列非空，则继续优先队列BFS，每次把一条边加入到答案集合中。因为是在求解最短路过程中向答案集合中加边，可知这就是一种最优策略。

　　参考代码：

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 const int Maxn=3e5+;
 const LL INF=1e15;
 int n,m,k,a[Maxn],f[Maxn],fa[Maxn];
 LL d[Maxn];
 bool boo[Maxn];
 struct qnode{
     int v;
     LL cost;
     bool operator < (const qnode &r) const {return cost>r.cost;}
 };
 struct node{
     int v;
     LL cost;
     int w;
 };
 vector<node> e[Maxn];
 set<int> s;
 set<int>::iterator it;

 void dijkstra()
 {
     for (int i=; i<=n; i++) boo[i]=false,d[i]=INF;
     priority_queue<qnode> q;
     while(!q.empty()) q.pop();
     d[]=;
     q.push(qnode{,});
     while (!q.empty())
     {
         qnode temp=q.top();q.pop();
         int u=temp.v;
         if (boo[u]) continue;
         boo[u]=true;
         for (int i=,len=e[u].size();i<len;i++)
         {
             int v=e[u][i].v;
             LL cost=e[u][i].cost;
             if(!boo[v] && d[v]>d[u]+cost)
             {
                 d[v]=d[u]+cost;
                 q.push(qnode{v,d[v]});
                 f[v]=e[u][i].w;
                 fa[v]=u;
             }
         }
     }
 }

 int main()
 {
     while(scanf("%d%d%d",&n,&m,&k)!=EOF)
     {
         for(int i=; i<=n; i++) e[i].clear();
         for(int i=; i<=m; i++)
         {
             int x,y,z;
             scanf("%d%d%d",&x,&y,&z);
             e[x].push_back(node{y,z,i});
             e[y].push_back(node{x,z,i});
         }
         dijkstra();
         if(k>=n-)
         {
             printf("%d\n",n-);
             for(int i=; i<=n; i++) if (i!=n) printf("%d ",f[i]); else printf("%d\n",f[i]);
         }
         else
         {
             s.clear();
             for(int i=; i<=n; i++) d[i]=;
             for(int i=; i<=n; i++) d[fa[i]]++,s.insert(f[i]);
             a[]=;
             for(int i=; i<=n; i++) if(d[i]==) a[++a[]]=i;
             int x=n-;
             while(x>k)
             {
                 int u=a[a[]];
                 a[]--;
                 s.erase(f[u]);
                 d[fa[u]]--;
                 if(d[fa[u]]==) a[++a[]]=fa[u];
                 x--;
             }
             printf("%d\n",x);
             int i=;
             for(it=s.begin();it!=s.end();it++)
             {
                 i++;
                 printf("%d",(*it));
                 if(i==x) printf("\n"); else printf(" ");
             }
         }
     }
     return ;
 }

Problem E. Vasya and a Tree

题目链接

题解：

题意：

给你一棵n个节点的树，每个点有一个权值，初始全为0，m次操作，每次三个数(v, d, x)表示只考虑以v为根的子树，将所有与v点距离小于等于d的点权值全部加上x，求所有操作完毕后，所有节点的值

首先要明确两件事情
性质1.每个人的操作只会影响到他的子孙(包括自己) 性质1.每个人的操作只会影响到他的子孙(包括自己)性质1.每个人的操作只会影响到他的子孙(包括自己)
性质2.每个人只会被他祖先的操作所影响(包括自己) 性质2.每个人只会被他祖先的操作所影响(包括自己)性质2.每个人只会被他祖先的操作所影响(包括自己)
也就是说，如果我们能在访问到某个节点时，统计出所有影响到该节点的祖先操作 也就是说，如果我们能在访问到某个节点时，统计出所有影响到该节点的祖先操作也就是说，如果我们能在访问到某个节点时，统计出所有影响到该节点的祖先操作
就可以统计出这个节点的最终权值 就可以统计出这个节点的最终权值就可以统计出这个节点的最终权值
而对于每个操作，我们只要用一个dep数组保存每个深度被增加的值 而对于每个操作，我们只要用一个dep数组保存每个深度被增加的值而对于每个操作，我们只要用一个dep数组保存每个深度被增加的值；
所有深度大于当前节点的操作都会影响到当前节点，如果用线段树就是一个区间求和问题 所有深度大于当前节点的操作都会影响到当前节点，如果用线段树就是一个区间求和问题所有深度大于当前节点的操作都会影响到当前节点，如果用线段树就是一个区间求和问题
为了减少代码量我们用树状数组，更新时只在本次操作的最深的深度更新 为了减少代码量我们用树状数组，更新时只在本次操作的最深的深度更新为了减少代码量我们用树状数组，更新时只在本次操作的最深的深度更新；
　　这样求一个1~maxdep的前缀和就是所有更新了根节点的操作 这样求一个1~maxdep的前缀和就是所有更新了根节点的操作这样求一个1~maxdep的前缀和就是所有更新了根节点的操作；
在求一个1~（nowdep-1)的前缀和就是所有不包含当前节点的操作 在求一个1~(nowdep-1)的前缀和就是所有不包含当前节点的操作在求一个1~(nowdep-1)的前缀和就是所有不包含当前节点的操作；两个前缀和相减就是当前节点被更新的值 两个前缀和相减就是当前节点被更新的值两个前缀和相减就是当前节点被更新的值；为了保证每个操作只影响自己子树内的节点，在dfs退出子树时 为了保证每个操作只影响自己子树内的节点，在dfs退出子树时为了保证每个操作只影响自己子树内的节点，在dfs退出子树时，要将当前根节点的所有修改值还原 要将当前根节点的所有修改值还原要将当前根节点的所有修改值还原。

参考代码：

 #include<bits/stdc++.h>
 using namespace std;
 #define clr(a,b) memset(a,b,sizeof a)
 #define PI acos(-1.0)
 #define lowbit(x) x&-x
 typedef long long ll;
 const int INF=0x3f3f3f3f;
 const int maxn=3e5+;
 vector<int> G[maxn],dep[maxn],val[maxn];
 int n,m,v,d,x,y;
 ll tree[maxn],ans[maxn];
 inline void readint(int &k)
 {
     int x=,f=;char ch=getchar();
     while(ch<''||ch>'') {if(ch=='-') f=-; ch=getchar();}
     while(ch>=''&&ch<='') {x=x*+ch-'';ch=getchar();}
     k=x*f;
 }

 inline void add(int x,int val)
 {
     while(x<=n)
     {
         tree[x]+=val;
         x+=lowbit(x);
     }
 }

 inline ll sum(int x)
 {
     ll ans=;
     while(x)
     {
         ans+=tree[x];
         x-=lowbit(x);
     }
     return ans;
 }

 inline void dfs(int t,int fa,int depth)
 {
     for(int i=;i<dep[t].size();++i) add(min(dep[t][i]+depth,n),val[t][i]);
     ans[t]=sum(n)-sum(depth-);
     for(int i=;i<G[t].size();++i)
     {
         if(G[t][i]==fa) continue;
         dfs(G[t][i],t,depth+);
     }
     for(int i=;i<dep[t].size();++i) add(min(dep[t][i]+depth,n),-val[t][i]);
 }

 int main()
 {
     clr(tree,);clr(ans,);
     readint(n);
     for(int i=;i<=n-;++i)
     {
         readint(x),readint(y);
         G[x].push_back(y);G[y].push_back(x);
     }
     readint(m);
     for(int i=;i<=m;++i)
     {
         readint(v),readint(d),readint(x);
         dep[v].push_back(d); val[v].push_back(x);
     }
     dfs(,,);
     for(int i=;i<=n;++i) printf("%lld%c",ans[i],i==n?'\n':' ');
     return ;
 }