Codeforces Round #686 Div3 前四题

一场大翻车，但是也从这次犯的错误里学到很多，希望能吸取这次的教训吧。

题目

A - Special Permutation

题意

给定一个大于1的数字n，请输入长度为n的一种置换，使得每个元素的下标（从1开始）与该元素的值不同。

思路

很简单，以$n,1,2,\dots ,n-2,n-1$ 的格式输出即可，一定不会出现与下标相同的

代码

#include <bits/stdc++.h>
#define N 1000000
#define Max_K 100000
#define PI acos(-1)
typedef long long ll;
using namespace std;
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n;
        scanf("%d", &n);
        printf("%d ", n);
        for(int i = 1; i < n; i++)
        {
            printf("%d ", i);
        }
        printf("\n");
    }
    return 0;
}

B - Unique Bid Auction

题意

n个人玩游戏，每个人独立给出一个数字（$1\le a_i\le n$），最后的赢家是所选数字最小并且与他人数字不重复的玩家。给定人数和每个人选的数字，要你给出赢家的序号。

思路

第一次被人hack，死在了memset上呜呜呜

思路是用三个数组（a[N], id[N], num[N]）分别存储元素的大小、元素的下标、元素的个数，因为$1\le a_i\le n$，所以从1到n，从小到大遍历，找到第一个个数刚好为1的数（num[i] = 0），去找他的对应下标（id[i]）即可。

需要注意的是，原题给定的数据范围是$\sum n\le 2\cdot 10^5$，如果使用memset，会导致在那些每个n特别小、总的组数特别大的情况下超时。 原理是memset每次是全部初始化，也就是说每次都是O（数组长度），组数如果特别大，初始化的时候就直接超时了，更不要说之后的程序了。

我也是因为memset被卡T并且hack了，以前用memset一路顺风顺水，一直都不知道有这么回事……以后一定注意。

代码

#include <bits/stdc++.h>
#define N 1000000
#define Max_K 100000
#define PI acos(-1)
typedef long long ll;
using namespace std;
int num[N];
int a[N];
int id[N];
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n;
        scanf("%d", &n);
        fill(a, a + n + 1, 0);
        fill(num, num + n + 1, 0);
        for(int i = 0; i < n; i++)
        {
            scanf("%d", a + i);
            id[a[i]] = i;
            num[a[i]]++;
        }
        sort(a, a + n);
        int ans = -1;
        for(int i = 0; i < n; i++)
        {
            if(num[a[i]] != 1)
                continue;
            ans = id[a[i]] + 1;
            break;
        }
        printf("%d\n", ans);
    }
    return 0;
}

吃一堑长一智

C - Sequence Transformation

题意

给定一个长度为n的数组，你可以选择其中的一段连续数字删掉。问最少删除几段数字，可以使剩下的数字全部都相同。注意：如果最后剩下的数字是x，则所有的x都不可以被删除。

思路

这题的本质是找能使数组被分割成最少段的数字x（x…x…x，数字x将数组分成两段），注意数字x不能包含在被删除的段中，也就是x要全选。比如12121，中间的1是不能删除的，最后是分割成2段。

那怎么看数字x会把数组分成几段呢？

• 首先，连续相同的数字，可以看成一个数字，比如…xxx…，只会把数组分成两段；
• 其次，在开头和在结尾的数字对分成几段不形成影响；
• 最后，如果所有数字都相同，则直接输出0（不需要删除就已经是全部相同）。

代码

#include <bits/stdc++.h>
#define N 1000000
#define INF 0x3f3f3f3f
#define PI acos(-1)
typedef long long ll;
using namespace std;
int a[N];
bool vis[N];
struct node
{
    int cnt;
    int id;
    node(){cnt = INF;id = INF;}
    node(int c, int i)
    {
        cnt = c;
        id = i;
    }
    operator < (const node & obj)
    {
        return cnt < obj.cnt;
    }
} num[N];

void init(int n)
{
    for(int i = 0; i < n + 1; i++)//千万不要用memset
    {
        num[i].cnt = INF;//最后排序的时候，数组中没有的数字就不会对排序结果造成影响
        num[i].id = INF;
        vis[i] = 0;
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n;
        scanf("%d", &n);
        init(n);
        bool flag = 0;
        for(int i = 0; i < n; i++)
        {
            scanf("%d", a + i);
            //因为初始化的时候num全部初始化为INF了，所以进行一轮赋值
            if(!vis[a[i]])
            {
                num[a[i]].id = a[i];
                num[a[i]].cnt = 0;
                vis[a[i]] = 1;
            }
            //如果和上一个数字相同，就不需要+1
            //但是如果恰好是最后一个数字，也就相当于这一整块都是可以算成最后一个数字的，都不对答案造成影响
            //所以减去之前遍历到第一个值为该数字时加的1
            if(i > 0 && a[i - 1] == a[i])
            {
                if(i == n - 1)
                    num[a[i]].cnt--;
                continue;
            }
            else if(i > 0)//如果和前一个数字不一样，说明不是全部相同的数字
            {
                flag = 1;
            }
            if(i == 0 || i == n - 1)//如果是第一个或最后一个，忽略
            {
                continue;
            }
            //对不满足以上条件的，+1
            num[a[i]].cnt++;
        }
        sort(num + 1, num + n + 1);//0不在范围内
        if(flag == 0)//如果全部数字都相同，输出0
        {
            printf("0\n");
            continue;
        }
        //否则输出最小的
        printf("%d\n", num[1].cnt + 1);
    }
    return 0;
}

需要注意的是，判断相邻数字相等要放在判断是否是第一个数字/最后一个数字的判断前面，这样可以顺便判断是否是每一个数字都相同的情况。赛后补题的时候因为这个WA了好几发。

D - Number into Sequence

题意

给定一个整数n，要求你根据n求出长度最长的数组a，数组a满足：
$$a[i+1]\mathrm{m}\mathrm{o}\mathrm{d}a[i]=0,\prod _{i=1}^{n}a[i]=n$$
（即：每个$a[i]$都能被$a[i-1]$整除，数组所有值相乘所得值为n）

要你给出最终数组的长度和每个元素的值，多个答案给任意一个即可。

思路

暴力，$[2,\sqrt{n}]$遍历，找出数字n个数最多的因子即可。因为只要求每个$a[i]$都能被$a[i-1]$整除，$a[i]$可以等于$a[i-1]$，所以只要找到个数最多的质因子x（必然是质数，因为合数肯定还能分出更多个因子），其个数num就是最长数组长度length。至于数组的具体构造，前length-1个的值均为x，最后一个数的值为$n/x^{num}$。

代码

#include <bits/stdc++.h>
#define N 100
#define INF 0x3f3f3f3f
#define PI acos(-1)
typedef long long ll;
using namespace std;

ll n;
ll nn;

ll qpow(ll x, ll n)
{
    ll ans = 1;
    while(n > 0)
    {
        if(n & 1)
        {
            ans *= x;
        }
        n >>= 1;
        x *= x;
    }
    return ans;
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%lld", &nn);
        n = nn;
        fill(a, a + 40, 1);
        int maxcnt = 1;
        ll maxid = -1;
        for(ll i = 2; i * i <= nn && n > 0; i++)
        {
            //if(i == 50010000)
                //cout << i * i << ' ' << nn << endl;
            int cnt = 0;
            while(n % i == 0)
            {
                n /= i;
                cnt++;
            }
            if(cnt > maxcnt)
            {
                maxcnt = cnt;
                maxid = i;
            }
        }
        printf("%d\n", maxcnt);
        if(maxcnt == 1)
            printf("%lld\n", nn);
        else
        {
            for(int i = 1; i < maxcnt; i++)
                printf("%lld ", maxid);
            printf("%lld\n", nn / qpow(maxid, maxcnt - 1));
        }
    }
    return 0;
}

赛后总结

• 不要随意使用memset，memset只是比O(n)快一点，输入和初始化的时间一定要考虑！

算是用一种惨痛的方式获得了早就该有的比赛经验

多多包涵，共同进步。