2018百度之星资格赛A B F

A.调查问卷

度度熊为了完成毕业论文，需要收集一些数据来支撑他的论据，于是设计了一份包含 mm 个问题的调查问卷，每个问题只有 'A' 和 'B' 两种选项。

将问卷散发出去之后，度度熊收到了 nn 份互不相同的问卷，在整理结果的时候，他发现可以只保留其中的一部分问题，使得这 nn 份问卷仍然是互不相同的。这里认为两张问卷是不同的，当且仅当存在至少一个被保留的问题在这两份问卷中的回答不同。

现在度度熊想知道，存在多少个问题集合，使得这 nn 份问卷在只保留这个集合的问题之后至少有 kk 对问卷是不同的。

Input

第一行包含一个整数 TT，表示有 TT 组测试数据。

接下来依次描述 TT 组测试数据。对于每组测试数据：

第一行包含三个整数 nn，mm 和 kk，含义同题目描述。

接下来 nn 行，每行包含一个长度为 mm 的只包含 'A' 和 'B' 的字符串，表示这份问卷对每个问题的回答。

保证 1 leq T leq 1001≤T≤100，1 leq n leq 10^31≤n≤10​3​​，1 leq m leq 101≤m≤10，1 leq k leq 10^61≤k≤10​6​​，给定的 nn 份问卷互不相同。

Output

对于每组测试数据，输出一行信息 "Case #x: y"（不含引号），其中 x 表示这是第 xx 组测试数据，y 表示满足条件的问题集合的个数，行末不要有多余空格。

Sample Input

2
2 2 1
AA
BB
2 2 2
AA
BB

Sample Output

Case #1: 3
Case #2: 0

思路：二进制枚举......将每种回答看成是二进制数A代表1，B代表0，则有n个二进制序列，将其转换成十进制数保存起来，总共有2^m 中不同的保留的问题集合；枚举这2^m种组合，找出每一种集合
所能产生多少对不同的问卷；若满足条件则ans++，最后的ans就是满足条件的问题集合数

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<map>

using namespace std;
int n,m,k,T,ans;
string a[1005];
int q[1005];
void change()
{
    for(int i=1;i<=n;i++){
        int w[20],tmp = 0;
        for(int j=0;j<a[i].size();j++){
            if(a[i][j]=='A')w[j] = 1;
            else w[j] = 0;
        }
        for(int j=0;j<a[i].size();j++)
            if(w[j])tmp+=1<<j;
        q[i] = tmp;
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>T;
    for(int i=1;i<=T;i++){
        ans = 0;
        cin>>n>>m>>k;
        for(int j=1;j<=n;j++)
            cin>>a[j];
        change();
        int t = pow(2,m);
        for(int j=1;j<=t;j++){
            map<int,int>p;
            for(int l=1;l<=n;l++){
                int ee = (j&q[l]);
                p[ee]++;
            }
            int sa = 0,sp = 0;
            for(auto c: p){
                if(c.second){
                    sa += c.second;
                    sp += c.second*(n-sa);
                }
            }
            if(sp>=k) ans++;
        }
        cout<<"Case #"<<i<<": "<<ans<<endl;
    }
    return 0;
}

B.子串查询

Problem Description

度度熊的字符串课堂开始了！要以像度度熊一样的天才为目标，努力奋斗哦！

为了检验你是否具备不听课的资质，度度熊准备了一个只包含大写英文字母的字符串 A[1,n] = a_1 a_2 cdots a_nA[1,n]=a​1​​a​2​​⋯a​n​​，接下来他会向你提出 $q$ 个问题 $(l,r)$，你需要回答字符串 A[l,r] = a_l a_{l+1} cdots a_rA[l,r]=a​l​​a​l+1​​⋯a​r​​ 内有多少个非空子串是 $A[l,r]$ 的所有非空子串中字典序最小的。这里的非空子串是字符串中由至少一个位置连续的字符组成的子序列，两个子串是不同的当且仅当这两个子串内容不完全相同或者出现在不同的位置。

记 $|S|$ 为字符串 $S$ 的长度，对于两个字符串 $S$ 和 $T$ ，定义 $S$ 的字典序比 $T$ 小，当且仅当存在非负整数 $k(\le \min (|S|,|T|))$ 使得 $S$ 的前 $k$ 个字符与 $T$ 的前 $k$ 个字符对应相同，并且要么满足 $|S|=k$ 且 $|T|>k$，要么满足 $k<\min (|S|,|T|)$ 且 $S$ 的第 $k+1$ 个字符比 $T$ 的第 $k+1$ 个字符小。例如 "AA" 的字典序比 "AAA" 小，"AB" 的字典序比 "BA" 小。

Input

第一行包含一个整数 $T$，表示有 $T$ 组测试数据。

接下来依次描述 $T$ 组测试数据。对于每组测试数据：

第一行包含两个整数 $n$ 和 $q$，表示字符串的长度以及询问的次数。

第二行包含一个长为 $n$ 的只包含大写英文字母的字符串 $A[1,n]$。

接下来 $q$ 行，每行包含两个整数 l_i,r_il​i​​,r​i​​，表示第 $i$ 次询问的参数。

保证 $1\le T\le 10$，1 leq n,q leq 10^51≤n,q≤10​5​​，1 leq l_i leq r_i leq n1≤l​i​​≤r​i​​≤n。

Output

对于每组测试数据，先输出一行信息 "Case #x:"（不含引号），其中 x 表示这是第 xx 组测试数据，接下来 qq 行，每行包含一个整数，表示字符串 A[l,r]A[l,r] 中字典序最小的子串个数，行末不要有多余空格。

Sample Input

1
2 3
AB
1 1
1 2
2 2

Sample Output

Case #1:
1
1
1

思路：前缀和，，，，，首先题意是要我们求[l,r]区间内最小的非空字串个数，也就是区间[l,r]中最小字母的个数；对于一个字符串我们用dp[i][j]来表示前i个字符中j的个数；
j代表'A'-'Z'；对于每一次查询，从A-Z输出第一个字母个数不为零的即可

#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>

using namespace std;
typedef long long LL;
const int maxn = 1e5+10;
LL dp[maxn][30];//dp[i][j] 代表前i个数中j的个数有多少个
LL T,n,q,l,r;
int main()
{
    ios::sync_with_stdio(false);
    cin>>T;
    for(int i=1;i<=T;i++){
        memset(dp,0,sizeof(dp));
        string str;
        cin>>n>>q;
        cin>>str;
        //前j个数里每个字母的个数
        for(int j=0;j<n;j++){
            dp[j][str[j]-'A']++;
            for(int k=0;k<26;k++)
                dp[j][k] += dp[j-1][k];
        }
        cout<<"Case #"<<i<<":"<<endl;
        while(q--){
            LL ans = 0;
            cin>>l>>r;
            l--;r--;
            for(int j=0;j<26;j++){
                if((dp[r][j]-dp[l-1][j])>0){
                    ans = dp[r][j]-dp[l-1][j];
                    break;
                }
            }
            cout<<ans<<endl;
        }
    }
    return 0;
}

F.三原色图

度度熊有一张 nn 个点 mm 条边的无向图，所有点按照 1,2,cdots,n1,2,⋯,n 标号，每条边有一个正整数权值以及一种色光三原色红、绿、蓝之一的颜色。

现在度度熊想选出恰好 kk 条边，满足只用这 kk 条边之中的红色边和绿色边就能使 nn 个点之间两两连通，或者只用这 kk 条边之中的蓝色边和绿色边就能使 nn 个点之间两两连通，这里两个点连通是指从一个点出发沿着边可以走到另一个点。

对于每个 k=1,2,cdots,mk=1,2,⋯,m，你都需要帮度度熊计算选出恰好 kk 条满足条件的边的权值之和的最小值。

Input

第一行包含一个正整数 TT，表示有 TT 组测试数据。

接下来依次描述 TT 组测试数据。对于每组测试数据：

第一行包含两个整数 nn 和 mm，表示图的点数和边数。

接下来 mm 行，每行包含三个整数 a,b,wa,b,w 和一个字符 cc，表示有一条连接点 aa 与点 bb 的权值为 ww、颜色为 cc 的无向边。

保证 1 leq T leq 1001≤T≤100，1 leq n,m leq 1001≤n,m≤100，1 leq a,b leq n1≤a,b≤n，1 leq w leq 10001≤w≤1000，c in {R,G,B}c∈{R,G,B}，这里 R,G,BR,G,B 分别表示红色、绿色和蓝色。

Output

对于每组测试数据，先输出一行信息 "Case #x:"（不含引号），其中 x 表示这是第 xx 组测试数据，接下来 mm 行，每行包含一个整数，第 ii 行的整数表示选出恰好 ii 条满足条件的边的权值之和的最小值，如果不存在合法方案，输出 -1−1，行末不要有多余空格。

Sample Input

1
5 8
1 5 1 R
2 1 2 R
5 4 5 R
4 5 3 G
1 3 3 G
4 3 5 G
5 4 1 B
1 2 2 B

Sample Output

Case #1:
-1
-1
-1
9
10
12
17
22

思路：最小生成树+贪心，分别对红绿，蓝绿边集合进行最小生成树，若两者都不能使得n个点互相联通则全输出-1，否则输出最小的权值；在每一次求完最小生成树之后将结果存入数组
　　　并且将没有用过的边按权值从小到大依次求出满足1-k条边的结果；最后将两次得出的结果比较输出较小值即可（由于我还是一名小菜鸡，代码繁杂就请各位大佬勿喷啦）

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>

using namespace std;
struct node{
    int from,to,cost;
    int value;//红绿蓝 对应 1 2 3 
    bool operator<(const node &a)const{
        return cost<a.cost;
    }
}e[500];
int n,m,T,k,cnt;
int f[200],vis[200],an[200],bn[200];
int Find(int x)
{
    if(x!=f[x])
        f[x] = Find(f[x]);
    return f[x];
}
void Union(int a,int b)
{
    int fa = Find(a);
    int fb = Find(b);
    if(fa!=fb)
        f[fa] = fb;
}
void add(int a,int b,int w,char c)
{
    e[cnt].from = a;
    e[cnt].to = b;
    e[cnt].cost = w;
    if(c=='R')e[cnt++].value = 1;
    else if(c=='G')e[cnt++].value = 2;
    else if(c=='B')e[cnt++].value = 3;
}
int Kruskal(int x,int y)
{
    int val,k = 0,ans = 0;
    if(x==1&&y==2) val = 3;
    else if(x==3&&y==2) val = 1;
    for(int i=0;i<=m;i++){
        f[i] = i;vis[i] = 0;
    }
    for(int i=0;i<m;i++){
        if(e[i].value!=val){
            if(Find(e[i].from)!=Find(e[i].to)){ 
                Union(e[i].from,e[i].to);
                k++;vis[i] = 1;
                ans += e[i].cost;
            }
        }
        if(k==(n-1))break;
    }
    if(k==(n-1))
        return ans;
    return -1;
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>T;
    int a,b,w;char c;
    for(int s=1;s<=T;s++){
        cin>>n>>m;
        k = m;cnt = 0;
        for(int i=0;i<m;i++){
            cin>>a>>b>>w>>c;
            add(a,b,w,c);
        }
        if(m<(n-1)){
            cout<<"Case #"<<s<<":"<<endl;
            for(int i=1;i<=m;i++)cout<<"-1"<<endl;
            continue;
        }
        sort(e,e+m);
        int flag1 = 0,flag2 = 0;
        
        for(int i=0;i<n-2;i++)an[i] = -1;
        // 第一次最小生成树找红绿边最小值 
        an[n-2] = Kruskal(1,2);
        if(an[n-2]!=-1) flag1 = 1;
        if(flag1){
            for(int i=n-1,j;i<m;i++){
                for(j=0;j<m;j++){
                    if(!vis[j]){
                        an[i] = an[i-1]+e[j].cost;
                        vis[j] = 1;
                        break;
                    }
                }
            }
        }
        //第二次最小生成树找蓝绿边最小值 
        for(int i=0;i<n-2;i++)bn[i] = -1;
        bn[n-2] = Kruskal(3,2);
        if(bn[n-2]!=-1)flag2 = 1;
        if(flag2){
            for(int i=n-1,j;i<m;i++){
                for(j=0;j<m;j++){
                    if(!vis[j]){
                        bn[i] = bn[i-1]+e[j].cost;
                        vis[j] = 1;
                        break;
                    }
                }
            }
        } 
        cout<<"Case #"<<s<<":"<<endl;
        if(!flag1&&!flag2){
            for(int i=0;i<m;i++)
                cout<<"-1"<<endl;
        }else if(!flag2){
            for(int i=0;i<m;i++)
                cout<<an[i]<<endl; 
        }else if(!flag1){
            for(int i=0;i<m;i++)
                cout<<bn[i]<<endl;
        }else{
            for(int i=0;i<m;i++)
                an[i] = min(an[i],bn[i]);
            for(int i=0;i<m;i++)
                cout<<an[i]<<endl;
        }
    }
    return 0;
}