2015_8

c 统计有几个cool单词，cool的定义就是至少两个字母，每个字母出现的次数都不同。

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<set>
 4 #define mt(a,b) memset(a,b,sizeof(a))
 5 using namespace std;
 6 set<int> s;
 7 char a[32];
 8 int b[32];
 9 int test(){
10     mt(b,0);
11     for(int i=0;a[i];i++){
12         b[a[i]-‘a‘]++;
13     }
14     s.clear();
15     int c=0;
16     for(int i=0;i<26;i++){
17         if(b[i]){
18             c++;
19             s.insert(b[i]);
20         }
21     }
22     return s.size()==c&&c>1;
23 }
24 int main(){
25     int n,cas=1;
26     while(~scanf("%d",&n)){
27         int ans=0;
28         while(n--){
29             scanf("%s",a);
30             ans+=test();
31         }
32         printf("Case %d: %d\n",cas++,ans);
33     }
34     return 0;
35 }

d 有向图，两个人从1走到n，问花费之和最小。一条边第一次走花费是d，第二次走花费是d+a。

最小费用最大流 ，两个人相当于流量2，原来一条边变为两条，流量都为1，费用一个d，一个d+a，源点连1，流量2，费用0，n连汇点，流量2，费用0.

  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #define mt(a,b) memset(a,b,sizeof(a))
  5 using namespace std;
  6 const int inf=0x3f3f3f3f;
  7 class MaxFlowMinCost { ///最小费用最大流 o(ME)
  8     typedef int typef;///流量的类型
  9     typedef int typec;///费用的类型
 10     static const int ME=10010;///边的个数
 11     static const int MV=510;///点的个数
 12     queue<int> q;
 13     int cur[MV],pre[MV];
 14     bool used[MV],sign[MV];
 15     typef flow;
 16     typec cost,dist[MV];
 17     bool spfa(int s,int t) {
 18         mt(used,0);
 19         mt(sign,0);
 20         mt(dist,0);
 21         used[s]=sign[s]=true;
 22         while(!q.empty()) q.pop();
 23         q.push(s);
 24         while(!q.empty()) {
 25             int u=q.front();
 26             q.pop();
 27             used[u]=false;
 28             for(int i=g.head[u]; ~i; i=g.e[i].next) {
 29                 if(g.e[i].flow<1) continue;
 30                 int v=g.e[i].v;
 31                 typec c=g.e[i].cost;
 32                 if(!sign[v]||dist[v]>dist[u]+c) {
 33                     dist[v]=dist[u]+c;
 34                     sign[v]=true;
 35                     pre[v]=u;
 36                     cur[v]=i;
 37                     if(used[v]) continue;
 38                     used[v]=true;
 39                     q.push(v);
 40                 }
 41             }
 42         }
 43         return sign[t];
 44     }
 45     struct G {
 46         struct E {
 47             int v,next;
 48             typef flow;
 49             typec cost;
 50         } e[ME];
 51         int le,head[MV];
 52         void init() {
 53             le=0;
 54             mt(head,-1);
 55         }
 56         void add(int u,int v,typef flow,typec cost) {
 57             e[le].v=v;
 58             e[le].flow=flow;
 59             e[le].cost=cost;
 60             e[le].next=head[u];
 61             head[u]=le++;
 62         }
 63     } g;
 64 public:
 65     void init() {
 66         g.init();
 67     }
 68     void add(int u,int v,typef flow,typec cost) {
 69         g.add(u,v,flow,cost);
 70         g.add(v,u,0,-cost);
 71     }
 72     void solve(int s,int t) {
 73         flow=cost=0;
 74         while(spfa(s,t)) {
 75             int temp=t;
 76             typef now=inf;
 77             while(temp!=s) {
 78                 now=min(now,g.e[cur[temp]].flow);
 79                 temp=pre[temp];
 80             }
 81             flow+=now;
 82             temp=t;
 83             while(temp!=s) {
 84                 int id=cur[temp];
 85                 cost+=now*g.e[id].cost;
 86                 g.e[id].flow-=now;
 87                 g.e[id^1].flow+=now;
 88                 temp=pre[temp];
 89             }
 90         }
 91     }
 92     typef getflow() {
 93         return flow;
 94     }
 95     typec getcost() {
 96         return cost;
 97     }
 98 }g;
 99 int main(){
100     int n,m,u,v,d,a,cas=1;
101     while(~scanf("%d%d",&n,&m)){
102         g.init();
103         while(m--){
104             scanf("%d%d%d%d",&u,&v,&d,&a);
105             g.add(u,v,1,d);
106             g.add(u,v,1,d+a);
107         }
108         int s=0,t=n+1;
109         g.add(s,1,2,0);
110         g.add(n,t,2,0);
111         g.solve(s,t);
112         printf("Case %d: %d\n",cas++,g.getcost());
113     }
114     return 0;
115 }

end