Acwing周赛分享

Acwing 周赛28

题面1

给定一个由大写字母构成的字符串 s，请计算其中有多少个子序列 QAQ。

注意，子序列不需要连续。

提示：本题数据范围较小，可以直接三重循环枚举三个字母的位置。

输入格式

一行，一个由大写字母构成的字符串 s。

输出格式

一个整数，表示 s 中子序列 QAQ 的个数。

数据范围

所有测试点满足 1≤|s|≤100。

输入样例1：

QAQAQYSYIOIWIN

输出样例1：

4

输入样例2：

QAQQQZZYNOIWIN

输出样例2：

3

Hint

注意子序列是可以不连续的 比如QAQQ 是有两个QAQ序列的

sol

注意到题面的数据范围是<=100的，也就是可以O(n^3)的解法。

也就是枚举每一个字母的位置，然后判断

代码

#include<iostream>
#include<utility>
#include<string>
using namespace std;
typedef long long ll;
#define fi(i,a,b) for(int i = a; i <= b; ++i)
#define fr(i,a,b) for(int i = a; i >= b; --i)
#define x first
#define y second
#define sz(x) ((int)(x).size())
#define pb push_back
using pii = pair<int,int>;
//#define DEBUG
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
#ifdef DEBUG
    //freopen(D:\in.txt,r,stdin);
#endif
    string sam;
    cin >> sam;
    int cnt = 0;
    fi(i,0,sz(sam)-1)
        fi(j,i+1,sz(sam)-1)
            fi(k,j+1,sz(sam)-1){
                if(sam[i] == 'Q' && sam[j] == 'A' && sam[k] == 'Q')
                    cnt++;
            }
    cout << cnt << endl;
    return 0;
}

题面2

给定一个长度为 n 的整数序列 a1,a2,…,an。

请你从中选出尽可能多的数。

要求满足如下两个条件之一：

仅选择一个数；

选择至少两个数，且所选择的数的最大公约数大于 1；

输出选出数的最大可能数量。

输入格式

第一行包含整数 n。

第二行包含 n 个整数 a1,a2,…,an。

输出格式

一个整数，表示选出数的最大可能数量。

数据范围

前 6 个测试点满足 1≤n≤10。

所有测试点满足 1≤n≤105，1≤ai≤105。

输入样例1：

3

2 3 4

输出样例1：

2

输入样例2：

5

2 3 4 6 7

输出样例2：

3

Hint

第一个样例选择2和4，最大公约数是2

第二个样例选择2，4，6，最大公约数是2

sol

如果要尽可能地选择多的数,那么肯定存在一个数是他们的最大公约数

1.如果选择的数中有最大的公约数，那么这个数显然是所选择序列中较小的数

我们可以尝试把每个数的质因子给筛出来，然后统计质因子最多的数，这样就是最终的答案

上述我们选择的这个数如果

是一个质数，上述的解法显然成立，可以用反证法证明

是一个合数，那么他肯定是某几个质数的乘积，那么上述的解法仍然正确，可以举例子说明

2.如果选择的数中没有最大的公约数

此情况其实等价于合数的情况

筛质因数的时间复杂度为O(n^1/2)

总的时间复杂度为O(n^3/2)

代码

#include<iostream>
#include<utility>
#include<unordered_map>
using namespace std;
typedef long long ll;
#define fi(i,a,b) for(int i = a; i <= b; ++i)
#define fr(i,a,b) for(int i = a; i >= b; --i)
#define x first
#define y second
#define sz(x) ((int)(x).size())
#define pb push_back
using pii = pair<int,int>;
//#define DEBUG
unordered_map<int,int> mapp;
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
#ifdef DEBUG
    //freopen(D:\in.txt,r,stdin);
#endif
    int n;
    cin >> n;
    fi(i,1,n){
        int x;
        cin >> x;
        fi(j,2,x/j){
            if(x % j == 0){
                mapp[j]++;
                while(x % j == 0){
                    x /= j;
                }
            }
        }
        if(x > 1) mapp[x]++;
    }
    int ans = 0;
    for(auto p:mapp) ans = max(ans,p.y);
    if(ans != 0)
        cout << ans << endl;
    else
        cout << 1 << endl;
    return 0;
}

题面3

有 n 个小朋友，编号 1∼n。

每个小朋友都拿着一个号码牌，初始时，每个小朋友拿的号码牌上的号码都等于其编号。

每个小朋友都有一个幸运数字，第 i 个小朋友的幸运数字为 di。

对于第 i 个小朋友，他可以向第 j 个小朋友发起交换号码牌的请求，当且仅当 |i−j|=di 成立。

注意，请求一旦发出，对方无法拒绝，只能立刻进行交换。

每个小朋友都可以在任意时刻发起任意多次交换请求。

给定一个 1∼n 的排列 a1,a2,…,an。

请问，通过小朋友相互之间交换号码牌，能否使得第 i 个小朋友拿的号码牌上的号码恰好为 ai，对 i∈[1,n] 均成立。

输入格式

第一行包含整数 n。

第二行包含 n 个整数 a1,a2,…,an。

第三行包含 n 个整数 d1,d2,…,dn。

输出格式

共一行，如果能做到，则输出 YES，否则输出 NO。

数据范围

前 6 个测试点满足 1≤n≤10。

所有测试点满足 1≤n≤100，1≤di≤n，保证 a1∼an 是一个 1∼n 的排列。

输入样例1：

5

5 4 3 2 1

1 1 1 1 1

输出样例1：

YES

输入样例2：

7

4 3 5 1 2 7 6

4 6 6 1 6 6 1

输出样例2：

NO

输入样例3：

7

4 2 5 1 3 7 6

4 6 6 1 6 6 1

输出样例3：

YES

Hint

对于第一个样例，刚开始都是1，2，3，4，5

经过一系列交换后显然可以成为5，4，3，2，1

每一个数只能跟他相邻的数交换

sol

刚开始看到数据只有100，想试试能不能用bfs搜素，因为这道题和八数码很像

写了一遍发现只能过将近一半的点

后面写了启发式搜素，虽然速度明显提升了很多，但是还是不能通过全部的点

当然，本题不是八数码那种类型，对于这个序列的每一个位置，只有两种可能去的点，而且每一个点不一定是可达的。如果是可达的，我们对这两个点进行建边，然后用floyd跑一遍，如果两个对应的点是可达的，

就说明对应的数可以通过这一系列交换使得对应的数互换位置，间接地说明其是可达的

算法时间复杂度为O(n^3)

此题有个很有趣的地方就是这个图最后跑出来是g[i][j]

i一定能通过一系列的变换到j，也就是i和j最后会实现交换

并且他们中间路径上的数也可以实现交换

最后的结果是只有i和j交换了，其他路上交换过的数都可以重新交换回来

之前想过一个问题就是，如果g[1][5]存在，那么1和5交换了，但是有可能5那个位置需要的不是1，而是4

那么如果g[5][4]存在

4无论之前通过怎样的交换，在最后都可以换到4这个位置来，然后到5的位置

做个推广，如果一个点到另一个点可达，那么他们路上的点到另一个点也是可达的

这个关系映射到这道题中就是无论4之前换到了任何其他位置，那么他还是可以换回到5这个位置

可以称之为交换的恒定有效性

代码

普通的bfs可以过接近一半的点

#include<iostream>
#include<utility>
#include<string>
#include<unordered_map>
#include<queue>
using namespace std;
typedef long long ll;
#define fi(i,a,b) for(int i = a; i <= b; ++i)
#define fr(i,a,b) for(int i = a; i >= b; --i)
#define x first
#define y second
#define sz(x) ((int)(x).size())
#define pb push_back
using pii = pair<int,int>;
//#define DEBUG
unordered_map<string,int> uor;
const int N = 105;
int d[N];
void bfs(string ss,string mir){
    queue<string> que;
    que.push(ss);
    while(!que.empty()){
        string p = que.front();
        que.pop();
        // cout << p << endl;
        if(p == mir) {cout << "YES" << endl; return;}
        uor[p]++;

        fi(i,0,sz(p) - 1){
            if(i + d[i] < sz(p)){
                string temp = p;
                swap(temp[i],temp[i+d[i]]);
                // cout << temp << endl;
                if(!uor[temp])
                    que.push(temp);
            }
            if(i - d[i] >= 0){
                string temp = p;
                swap(temp[i],temp[i - d[i]]);
                if(!uor[temp])
                    que.push(temp);
            }
        }

    }
    cout << "NO" << endl;
    return;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
#ifdef DEBUG
    //freopen(D:\in.txt,r,stdin);
#endif
    int n;
    cin >> n;
    string Balloon;
    string mir;

    fi(i,1,n){
        char c;
        cin >> c;
        Balloon.push_back(c);
    }
    fi(i,1,n) mir.push_back((char)(i+48));

    fi(i,0,n-1) cin >> d[i];

    bfs(mir,Balloon);
    return 0;
}

启发式搜素可以过一半的点

#include<iostream>
#include<utility>
#include<string>
#include<unordered_map>
#include<queue>
using namespace std;
typedef long long ll;
#define fi(i,a,b) for(int i = a; i <= b; ++i)
#define fr(i,a,b) for(int i = a; i >= b; --i)
#define x first
#define y second
#define sz(x) ((int)(x).size())
#define pb push_back
using pii = pair<int,int>;
//#define DEBUG
unordered_map<string,int> uor;
const int N = 105;
int d[N];
struct node{
    string st;
    int dis;
    bool operator < (const node p) const{
        return dis > p.dis;
    }
};
int Guass(string ss,string mir){
    int ans = 0;
    fi(i,0,sz(ss)-1){
        if(ss[i] != mir[i]) ans++;
    }
    return --ans;
}
priority_queue<node> que;
void bfs(string ss,string mir){
    que.push({ss,Guass(ss,mir)});
    while(!que.empty()){
        node p = que.top();
        que.pop();
        // cout << p << endl;
        if(p.st == mir) {cout << "YES" << endl; return;}
        uor[p.st]++;

        fi(i,0,sz(p.st) - 1){
            if(i + d[i] < sz(p.st)){
                string temp = p.st;
                swap(temp[i],temp[i+d[i]]);
                // cout << temp << endl;
                if(!uor[temp])
                    que.push({temp,Guass(temp,mir)+1+p.dis});
            }
            if(i - d[i] >= 0){
                string temp = p.st;
                swap(temp[i],temp[i - d[i]]);
                if(!uor[temp])
                    que.push({temp,Guass(temp,mir)+1+p.dis});
            }
        }

    }
    cout << "NO" << endl;
    return;
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
#ifdef DEBUG
    //freopen(D:\in.txt,r,stdin);
#endif
    int n;
    cin >> n;
    string Balloon;
    string mir;

    fi(i,1,n){
        char c;
        cin >> c;
        Balloon.push_back(c);
    }
    fi(i,1,n) mir.push_back((char)(i+48));

    fi(i,0,n-1) cin >> d[i];

    bfs(mir,Balloon);
    return 0;
}

正解1图论

#include<iostream>
#include<utility>
using namespace std;
typedef long long ll;
#define fi(i,a,b) for(int i = a; i <= b; ++i)
#define fr(i,a,b) for(int i = a; i >= b; --i)
#define x first
#define y second
#define sz(x) ((int)(x).size())
#define pb push_back
using pii = pair<int,int>;
//#define DEBUG
const int N = 105;
int d[N];
int Balloon[N];
int g[N][N];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
#ifdef DEBUG
    //freopen(D:\in.txt,r,stdin);
#endif
    int n;
    cin >> n;
    fi(i,1,n) cin >> Balloon[i];
    fi(i,1,n) cin >> d[i];

    fi(i,1,n) fi(j,1,n) g[i][j] = 0x3f3f3f3f;
    fi(i,1,n) g[i][i] = 0;

    fi(i,1,n){
        if(i + d[i] <= n)
            g[i][i+d[i]] = g[i+d[i]][i] = 1;
        if(i - d[i] >= 1)
            g[i][i-d[i]] = g[i-d[i]][i] = 1;
    }

    fi(k,1,n) fi(i,1,n) fi(j,1,n)
        g[i][j] = min(g[i][k] + g[k][j],g[i][j]);

    fi(i,1,n){
        if(g[i][Balloon[i]] == 0x3f3f3f3f) {
            cout << "NO" << endl;
            return 0;
        }
    }
    cout << "YES" << endl;
    return 0;
}

正解2并查集

用并查集实现的话相当于一个可达性问题，根据之前图论的思路。

时间复杂度为O(nlogn)

#include<iostream>
#include<utility>
using namespace std;
typedef long long ll;
#define fi(i,a,b) for(int i = a; i <= b; ++i)
#define fr(i,a,b) for(int i = a; i >= b; --i)
#define x first
#define y second
#define sz(x) ((int)(x).size())
#define pb push_back
using pii = pair<int,int>;
//#define DEBUG
const int N = 105;
int Balloon[N];
int d[N];
int f[N];
int find(int x){
    return f[x] == x ? x: f[x] = find(f[x]);
}
void combin(int x,int y){
    f[find(x)] = f[find(y)];
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
#ifdef DEBUG
    //freopen(D:\in.txt,r,stdin);
#endif
    int n;
    cin >> n;
    fi(i,1,n) cin >> Balloon[i];
    fi(i,1,n) cin >> d[i];
    fi(i,1,n) f[i] = i;
    fi(i,1,n){
        if(i + d[i] <= n) combin(i,i+d[i]);
        if(i - d[i] > 0) combin(i,i-d[i]);
    }
    fi(i,1,n){
        if(find(i) != find(Balloon[i]))
            {
                cout << "NO" << endl;
                return 0;
            }
    }
    cout << "YES" << endl;
    return 0;
}