2018"百度之星"程序设计大赛 - 资格赛

调查问卷

 Accepts: 1546

 Submissions: 6596

 Time Limit: 6500/6000 MS (Java/Others)

 Memory Limit: 262144/262144 K (Java/Others)

Problem Description

度度熊为了完成毕业论文，需要收集一些数据来支撑他的论据，于是设计了一份包含 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

可以把这些情况都2进制压位，那么就可以直接求出来了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define N 1005
int b[<<],dp[N][<<];;
char s[N][];
int main()
{
    int T,ca=,n,m,K;
    scanf("%d",&T);
    while(T--)
    {
        int i,j,k;
        scanf("%d%d%d",&n,&m,&K);
        for(i=; i<=n; i++)scanf("%s",s[i]);
        memset(dp,,sizeof(dp));
        for(i=; i<(<<m); i++)
        {
            memset(b,,sizeof(b));
            for(j=; j<=n; j++)
            {
                int S=;
                for(k=; k<m; k++)
                    if((i&(<<k))&&s[j][k]=='A')S|=<<k;
                b[S]++;
                dp[j][i]=dp[j-][i]+j-b[S];
            }
        }
        int ans=;
        for(i=; i<(<<m); i++)if(dp[n][i]>=K) ans++;
        printf("Case #%d: %d\n",++ca,ans);
    }
    return ;
}

子串查询

 Accepts: 4145

 Submissions: 17054

 Time Limit: 3500/3000 MS (Java/Others)

 Memory Limit: 262144/262144 K (Java/Others)

Problem Description

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

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

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

Input

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

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

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

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

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

保证 1 \leq T \leq 101≤T≤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

B我还傻不拉几RMQ？其实直接循环就好啦

#include<stdio.h>
#define min(a,b) a<b?a:b
const int N=2e5+;
char s[N];
int dmi[N][],f[N];
int sum[][N];
int n,q;
void RMQ_init()
{
    for(int j=; (<<j)<=n; j++)
        for(int i=; i+j-<=n; i++)
            dmi[i][j]=min(dmi[i][j-],dmi[i+(<<(j-))][j-]);
}
int RMQ(int l,int r)
{
    int k=f[r-l+];
    return min(dmi[l][k],dmi[r-(<<k)+][k]);
}
int main()
{
    int T,ca=;
    f[]=-;
    scanf("%d",&T);
    while(T--)
    {
        printf("Case #%d:\n",++ca);
        scanf("%d%d%s",&n,&q,s+);
        for(int i=; i<=n; i++)
        {
            dmi[i][]=s[i]-'A',f[i]=((i&(i-))==)?f[i-]+:f[i-];
            for(int j=; j<; j++)sum[j][i]=sum[j][i-]+(s[i]-'A'==j);
        }
        RMQ_init();
        for(int i=,l,r,z; i<q; i++)scanf("%d%d",&l,&r),z=RMQ(l,r),printf("%d\n",sum[z][r]-sum[z][l-]);
    }
    return ;
}

• HackStatus

 

三原色图

 Accepts: 708

 Submissions: 2974

 Time Limit: 1500/1000 MS (Java/Others)

 Memory Limit: 262144/262144 K (Java/Others)

Problem Description

度度熊有一张 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

Copy

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

---

跑两次最小生成树，但是一直wa啊，原来是Case，首字母大写

#include<bits/stdc++.h>
using namespace std;
const int N=,INF=0x3f3f3f3f;
int t,n,m,dsu[N],ans[N];
bool vis[N];
struct Edge
{
    int u,v,w,typ;
    void read()
    {
        char ch;
        scanf("%d%d%d %c",&u,&v,&w,&ch);
        typ=(ch=='R'?:(ch=='G'?:));
    }
    bool operator<(Edge const &t)const
    {
        return w<t.w;
    }
} e[N];
int dsu_find(int x)
{
    return dsu[x]<?x:(dsu[x]=dsu_find(dsu[x]));
}
bool dsu_merge(int u,int v)
{
    u=dsu_find(u),v=dsu_find(v);
    if(u==v)return ;
    if(dsu[u]<dsu[v])
        swap(u,v);
    dsu[v]-=dsu[u]==dsu[v];
    dsu[u]=v;
    return ;
}
void solve(int msk)
{
    int cnt=,sum=;
    memset(vis,,sizeof vis);
    memset(dsu,-,sizeof dsu);
    for(int i=; i<m; i++)
        if((e[i].typ&msk)&&dsu_merge(e[i].u,e[i].v))
        {
            ++cnt;
            sum+=e[i].w;
            vis[i]=;
        }
    if(cnt<n-)return;
    if(ans[cnt]>sum)ans[cnt]=sum;
    for(int i=; i<m; i++)
        if(!vis[i])
        {
            ++cnt;
            sum+=e[i].w;
            vis[i]=;
             if(ans[cnt]>sum)ans[cnt]=sum;
        }
}
int main()
{
    scanf("%d",&t);
    for(int ca=; ca<=t; ca++)
    {
        scanf("%d%d",&n,&m);
        for(int i=; i<m; i++)e[i].read();
        sort(e,e+m);
        memset(ans,0x3f,sizeof ans);
        solve();
        solve();
        printf("Case #%d:\n",ca);
        for(int i=; i<=m; i++)printf("%d\n",ans[i]<INF?ans[i]:-);
    }
    return ;
}

序列计数

 Accepts: 313

 Submissions: 1947

 Time Limit: 4500/4000 MS (Java/Others)

 Memory Limit: 262144/262144 K (Java/Others)

Problem Description

度度熊了解到，11,22,…,nn 的排列一共有 n! = n \times (n-1) \times \cdots \times 1n!=n×(n−1)×⋯×1 个。现在度度熊从所有排列中等概率随机选出一个排列 p_1p​1​​,p_2p​2​​,…,p_np​n​​，你需要对 kk=11,22,33,…,nn 分别求出长度为 kk的上升子序列个数，也就是计算满足 1 \leq a_11≤a​1​​ < a_2a​2​​ < … < a_ka​k​​ \leq n≤n 且 p_{a_1}p​a​1​​​​ <p_{a_2}p​a​2​​​​< … < p_{a_k}p​a​k​​​​ 的 kk 元组 (a_1a​1​​,a_2a​2​​,…,a_ka​k​​) 的个数。

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

Input

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

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

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

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

保证 1 \leq T \leq 1001≤T≤100，1 \leq n \leq 10^41≤n≤10​4​​，TT 组测试数据的 nn 之和 \leq 10^5≤10​5​​，p_1p​1​​,p_2p​2​​,…,p_np​n​​ 是 11,22,…,nn 的一个排列。

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

Output

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

Sample Input

2
4
1 2 3 4
4
1 3 2 4

Sample Output

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

---

除了样例，你可以认为给定的排列是从所有 11,22,…,nn 的排列中等概率随机选出的。这里面qls给了一个性质，就是这个期望是sqrt(n)

然后就不会了啊

tls的代码

#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e4 + , mod = (int)1e9 + ;
int t, n, perm[maxn], f[maxn], bit[maxn], ans[maxn];
int main() {
    scanf("%d", &t);
    for(int Case = ; Case <= t; ++Case) {
        scanf("%d", &n);
        for(int i = ; i <= n; ++i) {
            scanf("%d", perm + i);
            f[i] = ;
        }
        memset(ans + , , n * sizeof(int));
        ans[] = n;
        for(int i = ; i <= n; ++i) {
            memset(bit + , , n * sizeof(int));
            bool chk = ;
            for(int j = ; j <= n; ++j) {
                int o = perm[j], cur = ;
                for(int x = o - ; x > ; x -= x & -x)
                    (cur += bit[x]) >= mod && (cur -= mod);
                for(int x = o; x <= n; x += x & -x)
                    (bit[x] += f[o]) >= mod && (bit[x] -= mod);
                f[o] = cur;
                chk |= f[o];
                (ans[i] += f[o]) >= mod && (ans[i] -= mod);
            }
            if(!chk)
                break;
        }
        printf("Case #%d:", Case);
        for(int i = ; i <= n; ++i)
            printf(" %d", ans[i]);
        putchar('\n');
    }
    return ;
}

另一个聚聚的

#include<bits/stdc++.h>
using namespace std;
#define y1 y114514
#define pb push_back
#define mkp make_pair
#define fi first
#define se second
#define all(a) a.begin(), a.end()
typedef pair<int, int> pii;
typedef unsigned long long ull;
typedef long long ll;
const int M = ;

const int maxn = , maxk = ;

int T, n, ca;
int a[maxn], c[maxn], d[maxk][maxn];
int ans[maxn];

int ask(int x){
    int res = ;
    for(; x; x -= x & -x) res = max(res, c[x]);
    return res;
}

void modify(int x, int v){
    for(; x <= n; x += x & -x) c[x] = max(c[x], v);
}

int ask(int l, int x){
    int res = ;
    for(; x; x -= x & -x) res = (res + d[l][x]) % M;
    return res;
}

void add(int l, int x, int v){
    for(; x <= n; x += x & -x) d[l][x] = (d[l][x] + v) % M;
}

int main(){
    scanf("%d", &T);
    while(T--){
        scanf("%d", &n);
        for(int i = ; i <= n; ++i) scanf("%d", a + i);
        memset(c, , sizeof(c));

        for(int l = ; l <= ; ++l) memset(d[l], , sizeof(int) * (n + ));
        memset(ans, , sizeof(ans));
        for(int i = ; i <= n; ++i){
            int maxL = ask(a[i]); modify(a[i], maxL + );
            for(int l = maxL; l >= ; --l){
                int now = ask(l, a[i]);
                add(l + , a[i], now);
                ans[l + ] = (ans[l + ] + now) % M;
            }
            add(, a[i], );
        }
        ans[] = n;
        printf("Case #%d:", ++ca);
        for(int i = ; i <= n; ++i) printf(" %d", ans[i]);
        puts("");
    }

    return ;
}