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]);
   }
}