*Codeforces Round #201 (Div. 1)*

在出题人看到岛娘了，膜一下。感觉这场的题比上一场难了太多了。可能我太菜吧。

A Alice and Bob

思路：连懵带猜做出来的。求出n个数字的gcd，每个数字都除以gcd，然后得到一个新的集合。集合中最大的数字即最终集合中数字的个数。减掉已有数字的个数，即游戏能玩几回合。根据奇偶性判断胜负即可。看了tutorial，才想到思路。

假设有两个数字a，b，假设a>b，令d=gcd(a,b)，a=xd，b=yd，a-b=xd-yd=(x-y)d，就这样选数来回的减，最后得到的结果肯定是一个以d为首项，以d为公差的等差数列，最大值是a。当有n个数字的时候，这样每次选两个数字求差的绝对值，最后得到的最小的数是这n个数的gcd，得到的数字集合是以这个gcd为首项，且为公差的等差数列。然后总共的数字个数，就是最大的那个数除以gcd。

#include 
using namespace std;

const int MAXN = 110;
int nums[MAXN],n,maxn = 0,num;
void pre()
{

    int ggg = nums[0];
    for(int i = 1; i < n; ++i)
        ggg = __gcd(ggg,nums[i]);
    for(int i = 0; i < n; ++i)
    {
        nums[i] /= ggg;
        if(nums[i] > maxn) maxn = nums[i];
    }
}

int main()
{
    cin >> n;
    for(int i = 0; i < n; ++i)
        cin >> nums[i];
    pre();
    num = maxn-n;
    if(num&1) cout << "Alice" << endl;
    else cout << "Bob" << endl;
}

B Lucky Common Subsequence

参考：https://www.cnblogs.com/justPassBy/p/3963200.html
思路：起初我是dp求出所有的lcs，然后一个个去判，果然第四个测试就tle了。看了tutorial,说是kmp+dp或者ac自动机+dp。果断去复习了一下kmp，然后搜题解。感觉这个比D难多了，但是竟然那么多人做。不大会，打个 * ，日后再做。

C Number Transformation II

思路：贪心，表示想不到。首先去重，然后每次a = a-1或者a = a-a%nums[i]，选择一个最优的。当a-a%nums[i] < b的时候，就可以把这个nums[i]抛弃掉了，因为这个nums[i]已经没用了，想想就会发现，无论如何，只要用到这个nums[i]，那么肯定会a-a%nums[i] < b。但是这样为啥不会超时？表示不会分析。希望懂的大佬给留个分析。

#include 
using namespace std;

const int MAXN = 1e5+10;
int nums[MAXN];
int n,a,b,len;

int main()
{
    scanf("%d",&n);
    for(int i = 0;  i < n; ++i)
        scanf("%d",&nums[i]);
    scanf("%d %d",&a,&b);
    sort(nums,nums+n);
    len = unique(nums,nums+n) - nums;
    int now, res = 0;
    while(a > b)
    {
        now = a-1;
        for(int i = 0; i < len; ++i)
        {
            if(a - a%nums[i] < b) nums[i--] = nums[--len];
            else now = min(now,a - a%nums[i]);
        }
        a = now;
        ++res;
    }
    printf("%d\n",res);
    return 0;
}

D Robot Control

思路：最初想过动态规划，就是把s-t的过程反过来，记录每个点到t的花费最小的路径，然后不停先前更新，最后更新到s,得到结果，不过不知道怎么下手去写。就另寻他法，又想到拆点跑最短路，画了画样例，发现这样好像不行，因为如果岔路指向了走过的点，那个岔路在当前计算的时候，就不算了。。。参考了tutorial中的Ra16bit’s solution。代码是反向建图，从t向s进行dp。用一个双端队列维护走过的节点。用双端队列维护，是因为要让花费小的路径先往前走，拿样例调一下就知道了。然后就是从后向前dp。

#include 
using namespace std;

const int MAXN = 1e6+10;
vector<int> G[MAXN];
int dp[MAXN],out[MAXN];
int que[MAXN*2];
bool vis[MAXN];
int n,m,s,t;

int main()
{
    int u,v;
    scanf("%d %d",&n,&m);
    for(int i = 0; i < m ; ++i)
    {
        scanf("%d %d",&u,&v);
        G[v].push_back(u);
        out[u]++;
    }
    scanf("%d %d",&s,&t);
    memset(dp,-1,sizeof(dp));
    dp[t] = 0;
    int lt = MAXN,rt = MAXN+1;
    que[lt] = t;
    int cur;
    while(lt < rt)
    {
        cur = que[lt++];
        if(cur == s) break;
        if(vis[cur]) continue;
        vis[cur] = true;
        for(int i = 0; i < G[cur].size(); ++i)
        {
            v = G[cur][i];
            if(--out[v] == 0)
            {
                if(dp[v] > dp[cur] || dp[v] == -1)
                {
                    dp[v] = dp[cur];
                    que[--lt] = v;
                }
            }
            else if(dp[v] == -1)
            {
                dp[v] = dp[cur]+1;
                que[rt++] = v;
            }
        }
    }
    printf("%d\n",dp[s]);
    return 0;
}

E Doodle Jump

不会