2018年百度之星资格赛总结及解析

参赛时间：2018年8月4日—2018年8月6日

参赛队员：15332019张胜利

                  15332018张千艺

目录

1、问题描述和解题思路

2、赛事总结及体会

---

问题一：调查问卷

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

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

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

Input

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

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

第一行包含三个整数 n，m 和 k，含义同题目描述。

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

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

Output

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

Sample Input

Copy

2
2 2 1
AA
BB
2 2 2
AA
BB

Sample Output

Case #1: 3
Case #2: 0

---

解题思路：

题的大意为：一份m道题的调查问卷，然后让n个人做，现在要从这m道题中挑几道，使得剩下的题保证最少有k对人互相不一样。这里可以用组合数学的知识。

我们的思路就是用dfs枚举每一位，然后判断这一位是否合理。判断是否合理，复杂度为线性的：从n个人中选两个，然后减去从每种情况下选两个的情况枚举每一位情况的复杂度是2^m，判断的复杂度是n，整体就是n*2^m，差不多就是1e6的复杂度。

附上代码：

import java.util.*;
public class Main {
    static int arr[];	//arr储存转化为二进制后，每种情况的个数
    static int ans;	//表示最终结果
    static int num[];	//用来枚举每一位
    static String str[];
    static int k,n,m;
    public static void main(String[] args){
        arr=new int[1100];
        num=new int[11];
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        for(int j=1;j<=t;j++){
            ans=0;        
            n=sc.nextInt();
            m=sc.nextInt();
            k=sc.nextInt();
            str=new String[n];
            for(int i=0;i list=new LinkedList();//用一个队列把枚举过的情况储存起来，方便一会计算
        for(int i=0;i=k)ans++;
    }
}
​

---

问题二：子串查询

 

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

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

记 ∣S∣为字符串 S的长度，对于两个字符串 S 和 T，定义 S的字典序比 T 小，当且仅当存在非负整数 k(≤min(∣S∣,∣T∣)) 使得 S 的前 k 个字符与 T 的前 k 个字符对应相同，并且要么满足 ∣S∣=k 且 ∣T∣>k，要么满足 k

Input

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

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

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

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

接下来 q行，每行包含两个整数 li,ri，表示第 i 次询问的参数。

保证 1≤T≤10，1≤n,q≤10^5, n1≤l​i​​≤r​i​​≤n。

Output

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

Sample Input

Copy

1
2 3
AB
1 1
1 2
2 2

Sample Output

Copy

Case #1:
1
1
1

---

解题思路：

题目的意思就是找相应区间的字符串当中的字典序最小的子串的个数，认真按字典序的规律推一下就知道其实就是找最小单字符出现的次数，我们小学中学常用的字典开头第一页是不是肯定是"a"?

算法设计：这道题我们分析出来就是统计字母出现的个数。最容易想到的方法就是遍历，但当数据大时就是遍历起来就会非常繁琐。可以采用“前缀和”算法，统计字符串中每个字母在前i个字母中出现的次数，相当于预处理，然后在查询是直接以O(1)的时间复杂度来得出结果，在效率方面大大提高，这道题用前缀和在百度之星的资格赛中轻松AC。

附上代码：

#include
using namespace std;
const int MAXN = 1e5 + 1;
int sum[91][MAXN];//因为字母A-Z在ASCII上对应的是65—90，sum[65][i]就代表字母A在字符串的前i个字母中出现的次数。
char a[MAXN];
int main()

{
	int T, n, q, l, r;
	scanf("%d", &T);//在竞赛中尽量用Scanf，效率比cin高
	int num = 0;
	while (T--)
	{
		num++;
		printf("Case #%d:\n", num);
		scanf("%d", &n);
		scanf("%d", &q);
		//初始化
		for (int i = 65; i <= 90; i++)
		{
			for (int j = 0; j <= n; j++)
			{
				sum[i][j] = 0;
			}
		}
		//边输入边记录字母在前i个中出现的次数
		for (int i = 1; i <= n; i++)
		{
			cin >> a[i];
			for (int j = 65; j < 91; j++)
			{
				sum[j][i] = sum[j][i - 1];
			}
			sum[a[i]][i] = sum[a[i]][i - 1] + 1;
		}
		while (q--)
		{
			scanf("%d", &l);
			scanf("%d", &r);
		//从A开始遍历到Z,若某个字母出现的次数是零，则说明在[l,r]区间中没有这个字母
			for (int i = 65; i < 91; i++)
			{
				int temp = sum[i][r] - sum[i][l - 1];//前缀和的思想
				//若某个字母出现的次数非零，就说明是最小子串
				if (temp != 0)
				{
					printf("%d\n", temp);
					break;
				}
			}
		}
	}
	return 0;
}

---

问题三：序列计数

度度熊了解到，1,2,…,n 的排列一共有n!=n×(n−1)×⋯×1 个。现在度度熊从所有排列中等概率随机选出一个排列 p​1​​,p​2​​,…,p​n​​，你需要对 k=1,2,3,…,n 分别求出长度为 k 的上升子序列个数，也就是计算满足 1≤a​1​​ < a​2​​ < … < a​k​​ ≤n 且 p​a​1​​​​

由于结果可能很大，同时也是为了 ruin the legend， 你只需要输出结果对 1000000007(=10^9+7)取模后的值。

Input

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

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

第一行包含一个整数 n，表示排列的长度。

第二行包含 n 个整数 p​1​​,p​2​​, …, p​n​​，表示排列的 n 个数。

保证1≤T≤100，1≤n≤10​^4​​，T 组测试数据的 n 之和 ≤10^5，p​1​​，p​2​​,…,p​n​​ 是 1,2,…,n 的一个排列。

除了样例，你可以认为给定的排列是从所有 1,2,…,n 的排列中等概率随机选出的。

Output

对于每组测试数据，输出一行信息 "Case #x: c​1​​ c​2​​ ... c​n​​"（不含引号），其中 x 表示这是第 x 组测试数据，c​i​​ 表示长度为 i 的上升子序列个数对 1000000007(=10^9+7)取模后的值，相邻的两个数中间用一个空格隔开，行末不要有多余空格。

Sample Input

Copy

2
4
1 2 3 4
4
1 3 2 4

Sample Output

Copy

Case #1: 4 6 4 1
Case #2: 4 5 2 0

解题思路：

dp[i][k]表示：以a[i]为右端点时长度为k的上升子序列的个数，转换公式比较容易写出来

dp[i][k]=sum{dp[j][k-1]} (a[j]

可以看出有 i,j,k三重循环，时间复杂度为 O(n^3) 会TLE,因此看能不能减小一重循环

又转换方程看出，dp[i][k]为前i-1个a[j]

遍历排列a[i],用树状数组记录前 a[i] 的总和,则 dp[i][k]=Query(a[i]-1),而dp[i][k]又可以用dp[i]来代替,对于树状数组C[i]的处理，可用d[a[i]]保存a[i]的上升子序列个数，在计算d[a[i]]时先将其重置树状数组。

附上代码：

#include
using namespace std;
typedef long long LL;
const int MOD=1e9+7;
const int MAX_N=10005;
int n,T;
int a[MAX_N],d[MAX_N];
LL C[MAX_N];
int ans[MAX_N];

int Lowbit(int x);
void Update(int id,int x);
LL Query(int id);
int main()
{
	ios::sync_with_stdio(false);
	cin>>T;
	for(int t=1;t<=T;++t)
	{
		cin>>n;
		for(int i=1;i<=n;d[i]=1,ans[i]=0,++i)
			cin>>a[i];
		ans[1]=n;
		for(int k=2;k<=n;++k)
		{
			for(int i=1;i<=n;++i)
				C[i]=0;
			LL sum=0;
			for(int i=1;i<=n;++i)
			{
				Update(a[i],d[a[i]]);
				d[a[i]]=Query(a[i]-1)%MOD;
				sum+=d[a[i]];
			}
			ans[k]=sum%MOD;
			if(!ans[k])	break;
		}
		cout<<"Case #"<0){
		ans+=C[id];
		id-=Lowbit(id);
	}
	return ans;
}

问题四：

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

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

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

Input

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

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

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

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

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

Output

对于每组测试数据，先输出一行信息 "Case #x:"（不含引号），其中 x 表示这是第 x 组测试数据，接下来 m 行，每行包含一个整数，第 i 行的整数表示选出恰好 i 条满足条件的边的权值之和的最小值，如果不存在合法方案，输出 −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

解题思路：

用两次kruscal算法，一次只用条件一的边，一次用条件二的边。每次跑完之后在依次加入剩下的边更新ans，如果无法联通答案就都是-1了。

附上代码：

#include
using namespace std;
#define LL long long 
#define pb push_back
#define inf 0x3f3f3f3f
int f[111];
int getf(int u){return f[u]==u?u:f[u]=getf(f[u]);}
struct Edge{
    int u,v,w,col,sel;
    bool operator<(const Edge& C)const{
        return w>ch;
            if(ch=='R') e[i].col=0;
            else if(ch=='G') e[i].col=1;
            else if(ch=='B') e[i].col=2;
        }
        sort(e+1,e+1+m);
        memset(ans,-1,sizeof(ans));
        mst(0);
        mst(2);
        
        printf("Case #%d:\n",++cas);
        for(i=1;i<=m;++i) printf("%d\n",ans[i]);
    }
    return 0;
}

赛事总结及体会：

这次比赛对于我们来说是一个学习和检验的机会。在完成三年的大学课程之后是对我们学习能力，知识掌握情况的检验。期间也遇见过各种各样的问题。但通过不断地调整和学习，也能渐渐地摸索出方法。虽然没能在比赛中拿到名次，但也锻炼了自己的能力和团队协作能力。了解到算法对于日常实际问题的重要性，学习好算法会很大程度上帮助我们解决好遇见的各种问题。希望在以后的学习中能将在比赛时的热情和努力一直去传递下去。对未来的自己说加油，努力努力！