Codeforces Round #374 (Div. 2) A~D

Ａ
题意＆思路：找到Ｂ连续出现的个数

#include<bits/stdc++.h>using namespace std;vector<int>ans;int main(){    int n;    while(cin>>n){        string s;cin>>s;        ans.clear();        int t=0;        for(int i=0;i<n;i++){            if(s[i]=='B'){                t++;            }            else{                if(t>0) ans.push_back(t);                t=0;            }        }        if(t>0) ans.push_back(t);        if(ans.size()==0){            cout<<0<<endl;            continue;        }        cout<<ans.size()<<endl;        for(int i=0;i<ans.size()-1;i++) cout<<ans[i]<<" ";        cout<<ans[ans.size()-1]<<endl;    }}

Ｂ
题意＆思路：ｎ个串，问你如果从长度从小到大，（也就是同一个长度可以决定谁最先最后），随机找到心仪的那个需要最少时间和最多时间，每一次查找需要1秒，每隔ｋ个串需要额外5秒。

#include<bits/stdc++.h>using namespace std;string s[110],str;int main(){       int n,k;       while(cin>>n>>k){          for(int i=0;i<n;i++) cin>>s[i];          cin>>str;          int t1=0,t2=0;          for(int i=0;i<n;i++){              if(s[i].size()<str.size()) t1++;              if(s[i].size()<=str.size()) t2++;          }          t1+=1;          t1=(t1-1)/k*5+t1;t2=(t2-1)/k*5+t2;          cout<<t1<<" "<<t2<<endl;       }}

C. Journey（补）

题意：
在一个DAG图上（有向无环），每条边都有一个时间t[i]的权值，给你总时间T，问从1点出发到n
点总时间小于T并且经过点的个数最多的路线。

思路：典型的DAG图上的动态规划.亏我暴力一小时。。。。

可以从两种不同角度定义dp数组，从而状态转移。
dp[i][j]
1: 表示从i点出发到n点已经经过j个点的最少时间。
那么这种转移初始化dp[n][0]=0,每个状态的子状态就是他的儿子到n点少经过一个点花费的时间，那么转移方向就是从n点到1点的方向进行。

我用邻接表存下这个DAG图，一遍记忆化dfs(1)，
状态转移方程：dp[i][j]=min(dp[k][j-1]+edge(i,k)) (k是i点子节点)
时间复杂度O（n）。

#include<bits/stdc++.h>using namespace std;const int maxn=5000+5;template<int N,int M>struct Graph{    int top;    struct Vertex{        int head;    }V[N];    struct Edge{        int v,next,t;    }E[M];    void init(){        memset(V,-1,sizeof(V));        top = 0;    }    void add_edge(int u,int v,int t){        E[top].v = v;        E[top].t=t;        E[top].next = V[u].head;        V[u].head = top++;    }};Graph<maxn,maxn> g;int n,m,T,dp[maxn][maxn],pre[maxn][maxn],vis[maxn];void dfs(int cur){   if(vis[cur]!=0) return; vis[cur]=1;   if(cur==n) dp[cur][1]=0;   for(int i=g.V[cur].head;i!=-1;i=g.E[i].next){      int s=g.E[i].v;dfs(s);      for(int j=1;j<=n;j++){        if(dp[s][j-1]+g.E[i].t<dp[cur][j]){            dp[cur][j]=dp[s][j-1]+g.E[i].t;            pre[cur][j]=s;        }      }   }}void print(int t,int x){    printf("%d ",x);    if(t>1) print(t-1,pre[x][t]);}int main(){    while(~scanf("%d%d%d",&n,&m,&T)){       g.init();       memset(vis,0,sizeof(vis));       memset(dp,0x3f,sizeof(dp));       for(int i=0;i<m;i++){          int a,b;          int c;scanf("%d%d%d",&a,&b,&c);          g.add_edge(a,b,c);       }       dfs(1);       int ans=0;       for(int i=n;i>=0;i--){         if(dp[1][i]<=T){            ans=i;break;         }       }       printf("%d\n",ans);       print(ans,1);       printf("\n");   }}

2：
表示从1点出发到i点经过了j个点的最少时间。
那么相当于上面，这里初始化dp[1][0]=0;
,每个状态的子状态就是1到它父亲少经过一个点花费的时间，那么转移方向就是从1点到n点的方向进行。那么邻接表存图就得反向，从n到1。
状态转移方程：**dp[i][j]=min(dp[k][j-1]+edge(i,k)) (k是i点父节点)
时间复杂度O（n）。

#include<bits/stdc++.h>using namespace std;const int maxn=5000+5;template<int N,int M>struct Graph{    int top;    struct Vertex{        int head;    }V[N];    struct Edge{        int v,next,t;    }E[M];    void init(){        memset(V,-1,sizeof(V));        top = 0;    }    void add_edge(int u,int v,int t){        E[top].v = v;        E[top].t=t;        E[top].next = V[u].head;        V[u].head = top++;    }};Graph<maxn,maxn> g;int n,m,T,dp[maxn][maxn],pre[maxn][maxn],vis[maxn];void dfs(int cur){   if(vis[cur]!=0) return; vis[cur]=1;   if(cur==1) dp[cur][1]=0;   for(int i=g.V[cur].head;i!=-1;i=g.E[i].next){       int f=g.E[i].v;dfs(f);       for(int j=1;j<=n;j++){          if(dp[f][j-1]+g.E[i].t<dp[cur][j]){             dp[cur][j]=dp[f][j-1]+g.E[i].t;             pre[cur][j]=f;          }       }   }}void print(int t,int x){   if(t>1) print(t-1,pre[x][t]); printf("%d ",x);}int main(){   while(~scanf("%d%d%d",&n,&m,&T)){       g.init();       memset(vis,0,sizeof(vis));       memset(dp,0x3f,sizeof(dp));       for(int i=0;i<m;i++){          int a,b;          int c;scanf("%d%d%d",&a,&b,&c);          g.add_edge(b,a,c);       }       dfs(n);       int ans=0;       for(int i=n;i>=0;i--){         if(dp[n][i]<=T){            ans=i;break;         }       }       printf("%d\n",ans);       print(ans,n);       printf("\n");   }}

这两种做法本质都一样,定义好状态，就在ＤＡＧ图上转移！

D. Maxim and Array
题意：给你ｎ个数，ｋ次操作，每次只能对一个数＋ｘ或－ｘ，问最后使它们乘积最小的情况是。
思路：一顿贪心＋优先队列logn的优化。(个人感觉比C简单，应该换一下)
如果n个数里，负数的个数是奇数个，就让排序后绝对值最小的数绝对值的增加x.
反之负数的个数是偶数，就让绝对值最小的数绝对值的减小x。每次操作后，序列绝对值最小的数会变化，用优先队列维护。
时间复杂度O(n+k*(logn));

#include<bits/stdc++.h>using namespace std;typedef long long ll;struct node{    ll v; int p;    friend bool operator <(node a,node b){        return abs(a.v)>abs(b.v);    }};priority_queue<node>q;ll a[200000+10];int main(){   int n,k,x;   while(~scanf("%d %d %d",&n,&k,&x)){      while(!q.empty()) q.pop();      int num=0,ok=0;      for(int i=0;i<n;i++){         scanf("%lld",&a[i]);q.push(node{a[i],i});         if(a[i]<0) num++;      }      while(k--){         if(num%2==0){            node t=q.top(); q.pop();            int s=t.v,e;            if(t.v>=0){                a[t.p]-=x; t.v-=x;                e=t.v;            }            else{                a[t.p]+=x; t.v+=x;                e=t.v;            }            q.push(t);            if(s>=0&&e<0) num++;            if(s<0&&e>=0) num--;         }         else{            node t=q.top();q.pop();            if(t.v>=0){                a[t.p]+=x; t.v+=x;            }            else{                a[t.p]-=x; t.v-=x;            }            q.push(t);         }      }      for(int i=0;i<n-1;i++) printf("%lld ",a[i]);      printf("%lld\n",a[n-1]);   }}