2016"百度之星" - 初赛（Astar Round2A）

All X

 

 Accepts: 1281

 

 Submissions: 7580

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

 

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

Problem Description

$F(x,m)$ 代表一个全是由数字$x$组成的$m$位数字。请计算，以下式子是否成立：

$F(x,m)modk\equiv c$

Input

第一行一个整数$T$，表示$T$组数据。 每组测试数据占一行，包含四个数字$x,m,k,c$

$1\le x\le 9$

1\leq m\leq 10^{10}1≤m≤10​10​​

$0\le c<k\le 10,000$

Output

对于每组数据，输出两行： 第一行输出："Case #i:"。$i$代表第$i$组测试数据。 第二行输出“Yes” 或者 “No”，代表四个数字，是否能够满足题目中给的公式。

Sample Input

3
1 3 5 2
1 3 5 1
3 5 99 69

Sample Output

Case #1:
No
Case #2:
Yes
Case #3:
Yes


    
    

     
     

      
      Hint
     
     
对于第一组测试数据：111 mod 5 = 1，公式不成立，所以答案是”No”，而第二组测试数据中满足如上公式，所以答案是 “Yes”。

    
    

题解： 抽屉原理，因为k最大10000，所以最多模10000次后，肯定会出现循环节。

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <vector>
#include <map>
#include <string.h>

using namespace std;
typedef long long ll;
map<int,int> mp;
vector<int> vec;

int main()
{
    int T,cnt = 0;
    ll x,m,k,c;
    cin >> T;
    while(T--)
    {
        mp.clear();
        vec.clear();
        cin >> x >> m >> k >> c;
        ll tp = 0;
        int ans = -1;
        for(int i = 1; i <= m; ++i)
        {
            tp = tp * 10 + x;
            tp %= k;
//            cout << tp << endl;
            if(mp[tp])
            {
                int len = i - mp[tp];
                m -= mp[tp] - 1;
                m %= len;
                if(m == 0) ans = vec[vec.size() - 1];
                else ans = vec[mp[tp] + m - 1];
                break;
            }
            vec.push_back(tp);
            mp[tp] = i;
        }
        if(ans == -1) ans = vec[m - 1];
        printf("Case #%d:\n",++cnt);
        puts(ans == c ? "Yes" : "No");
    }
    return 0;
}

BD String

 

 Accepts: 388

 

 Submissions: 1164

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

 

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

Problem Description

众所周知，度度熊喜欢的字符只有两个：B和D。

今天，它发明了一种用B和D组成字符串的规则：

$S(1)=B$

$S(2)=BBD$

$S(3)=BBDBBDD$

…

$S(n)=S(n-1)+B+reverse(flip(S(n-1))$

其中，$reverse(s)$指将字符串翻转，比如$reverse(BBD)=DBB$，$flip(s)$指将字符串中的$B$替换为$D$，$D$替换为$B$，比如$flip(BBD)=DDB$。

虽然度度熊平常只用它的电脑玩连连看，这丝毫不妨碍这台机器无与伦比的运算速度，目前它已经算出了S(2^{1000})S(2​1000​​)的内容，但度度熊毕竟只是只熊，一次读不完这么长的字符串。它现在想知道，这个字符串的第$L$位（从1开始）到第$R$位，含有的$B$的个数是多少？

Input

第一行一个整数$T$，表示$T(1\le T\le 1000)$ 组数据。

每组数据包含两个数$L$和R(1 \leq L \leq R \leq 10^{18})R(1≤L≤R≤10​18​​) 。

Output

对于每组数据，输出S(2^{1000})S(2​1000​​)表示的字符串的第$L$位到第$R$位中$B$的个数。

Sample Input

3
1 3
1 7
4 8

Sample Output

2
4
3

题解： 由S(n) = S(n - 1) + B + reverse(flip(S(n - 1))) 知S(n)为一个伪回文串，如果没有flip操作，就是回文串。由回文串的定义知，mid左右两边的B数量是相等的，在左右距离mid相等的情况下，由这个特性，就可以划分区间了。分两种情况考虑，如果L,R都在mid右边，那么可以把区间映射到mid左边，此时求B数量，相当于求D数量，因为flip操作。如果L<=mid && R >= mid，那么可以从mid左右两边取相等长度的区间，剩下的区间在考虑是在mid的左边还是右边，如果是右边的话，就要进行映射，换为求D的数量。所以整个算法只需要递归最多60层就可以得出解了。时间复杂度为log（R-L+1)

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <vector>
#include <map>
#include <queue>
#include <string.h>
#include <algorithm>

using namespace std;
typedef long long ll;
const int N = 1e5 + 5;

ll dfs(ll l,ll r,int v)
{
    ll tp = 0,cnt = 0,mid;
    for(int i = 1; ; ++i)
    {
        mid = tp + 1;
        tp = tp * 2 + 1;
        if(tp >= r) break;
    }
    if(l <= mid && r >= mid)
    {
        if(mid - l > r - mid)
        {
            if(v == 0) cnt++;
            cnt += r - mid;
            cnt += dfs(l,2 * mid - r - 1,v);
        }
        else if(mid - l < r - mid)
        {
            if(v == 0) cnt++;
            cnt += mid - l;
            l = 2 * mid - l + 1;
            cnt += dfs(2 * mid - r,2 * mid - l,v ^ 1);
        }
        else
        {
            if(v == 0) cnt++;
            cnt += mid - l;
        }
    }
    else if(l > mid)
    {
        cnt += dfs(2 * mid - r,2 * mid - l,v ^ 1);
    }
    return cnt;
}

void solve()
{
    int T;
    cin>>T;
    while(T--)
    {
        ll L,R;
        cin >> L >> R;
        cout << dfs(L,R,0) << endl;
    }
}

int main()
{
    solve();
    return 0;
}

Gym Class

 

 Accepts: 849

 

 Submissions: 4247

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

 

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

Problem Description

众所周知，度度熊喜欢各类体育活动。

今天，它终于当上了梦寐以求的体育课老师。第一次课上，它发现一个有趣的事情。在上课之前，所有同学要排成一列， 假设最开始每个人有一个唯一的ID，从1到$N$，在排好队之后，每个同学会找出包括自己在内的前方所有同学的最小ID，作为自己评价这堂课的分数。麻烦的是，有一些同学不希望某个（些）同学排在他（她）前面，在满足这个前提的情况下，新晋体育课老师——度度熊，希望最后的排队结果可以使得所有同学的评价分数和最大。

Input

第一行一个整数$T$，表示$T(1\le T\le 30)$ 组数据。

对于每组数据，第一行输入两个整数$N$和$M(1\le N\le 100000,0\le M\le 100000)$，分别表示总人数和某些同学的偏好。

接下来$M$行，每行两个整数$A$ 和$B(1\le A,B\le N)$，表示ID为$A$的同学不希望ID为$B$的同学排在他（她）之前。你可以认为题目保证至少有一种排列方法是符合所有要求的。

Output

对于每组数据，输出最大分数 。

Sample Input

3
1 0
2 1
1 2
3 1
3 1

Sample Output

1
2
6

题解： 这道是一道贪心题，知道每次要把最大的数放在前面就行了，搞一个拓扑排序，乱搞搞就过了。

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <vector>
#include <map>
#include <queue>
#include <string.h>

using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
vector<int> vec;
vector<int> G[N];
int in[N];

void topSort(int n)
{
    priority_queue<int> que;
    for(int i = 1; i <= n; ++i)
    {
        if(in[i] == 0) que.push(i);
    }
    while(!que.empty())
    {
        int tp = que.top();
        que.pop();
        vec.push_back(tp);
        for(int i = 0; i < G[tp].size(); ++i)
        {
            int v = G[tp][i];
            in[v]--;
            if(in[v] == 0) que.push(v);
        }
    }
}

void solve()
{
    int T,n,m;
    cin >> T;
    while(T--)
    {
        scanf("%d %d",&n,&m);
        for(int i = 1; i <= n; ++i) G[i].clear();
        vec.clear();
        memset(in,0,sizeof in);
        for(int i = 0; i < m; ++i)
        {
            int u,v;
            scanf("%d %d",&u,&v);
            G[u].push_back(v);
            in[v]++;
        }
        topSort(n);
        ll ans = 0,Min = n + 1;
        for(int i = 0; i < n; ++i)
        {
//            cout << vec[i] <<  ' ';
            if(vec[i] < Min)
                Min = vec[i];
            ans += Min;
        }
//        puts("");
        cout << ans << endl;
    }
}

int main()
{
    solve();
    return 0;
}
Close