标签：col contains examples 相关 operation 替换 angular 次数 with
标签（空格分隔）： ACM
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
for the array \([0, 0, 1, 0, 2]\) MEX equals to \(3\) because numbers \(0, 1\) and \(2\) are presented in the array and \(3\) is the minimum non-negative integer not presented in the array; for the array \([1, 2, 3, 4]\) MEX equals to \(0\) because \(0\) is the minimum non-negative integer not presented in the array; for the array \([0, 1, 4, 3]\) MEX equals to \(2\) because \(2\) is the minimum non-negative integer not presented in the array. You are given an empty array \(a=[]\) (in other words, a zero-length array). You are also given a positive integer \(x\).
You are also given \(q\) queries. The \(j\)-th query consists of one integer \(y_j\) and means that you have to append one element \(y_j\) to the array. The array length increases by \(1\) after a query.
In one move, you can choose any index \(i\) and set \(a_i := a_i + x\) or \(a_i := a_i - x\) (i.e. increase or decrease any element of the array by \(x\)). The only restriction is that \(a_i\) cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of \(q\) queries (i.e. the \(j\)-th answer corresponds to the array of length \(j\)).
Operations are discarded before each query. I.e. the array \(a\) after the \(j\)-th query equals to \([y_1, y_2, \dots, y_j]\).
The first line of the input contains two integers \(q, x\) (\(1 \le q, x \le 4 \cdot 10^5\)) — the number of queries and the value of \(x\).
The next \(q\) lines describe queries. The \(j\)-th query consists of one integer \(y_j\) (\(0 \le y_j \le 10^9\)) and means that you have to append one element \(y_j\) to the array.
Print the answer to the initial problem after each query — for the query \(j\) print the maximum value of MEX after first \(j\) queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
7 3
0
1
2
2
0
0
10
1
2
3
3
4
4
7
4 3
1
2
1
2
0
0
0
0
本题看着比较复杂，看起来比较像模拟题，其实是一道数学题，仔细理解题意，可以看出，将序列中的每一个元素对x取模可以得到0-x-1的数（记为M序列），所以MEX取决于M序列的个数和多余出来的那部分数，我们只需要对每次读取的数字进行更新和维护，记录此时M序列的个数和多出来的那部分数，此时M序列的个数应该为M序列中最少数量的那个元素的个数，此时这个元素必定已经用完，所以在新多出来的序列中这个元素必然缺少，所以这个元素就是多出来序列的MEX，更新ans=s.begin()->first * x+s.begin()->second,本题使用的set相关知识应该掌握。
代码1：
#include <bits/stdc++.h>
using namespace std;
int main()
{
int q,x;
scanf("%d %d",&q,&x);
vector<int> v(x);
//set<pair<int, int> > vals;
set<pair<int, int> > s;
for(int i=0;i<x;i++)
{
s.insert(make_pair(v[i],i));
}
for(int i=0;i<q;i++)
{
int cus;
scanf("%d",&cus);
cus%=x;
s.erase(make_pair(v[cus], cus));
v[cus]++;
s.insert(make_pair(v[cus],cus));
//cout << s.begin()->first * x + s.begin()->second << endl;
printf("%d\n",s.begin()->first * x+s.begin()->second);
}
return 0;
}代码2：
#include <bits/stdc++.h>
using namespace std;
const int maxn=400005;
int cnt[maxn];
int main()
{
int q,x;
scanf("%d %d",&q,&x);
int ans=0;
int j=0;
for(int i=0;i<q;i++)
{
int cur;
scanf("%d",&cur);
cnt[cur%x]++;
while(true)
{
if(cnt[j]>0)
{
cnt[j]--;
ans++;
j=(j+1)%x;
}
else
break;
}
printf("%d\n",ans);
}
//cout << "Hello world!" << endl;
return 0;
}
You are given a rectangular matrix of size \(n \times m\) consisting of integers from \(1\) to \(2 \cdot 10^5\).
In one move, you can:
choose any element of the matrix and change its value to any integer between \(1\) and \(n \cdot m\), inclusive; take any column and shift it one cell up cyclically (see the example of such cyclic shift below). A cyclic shift is an operation such that you choose some \(j\) (\(1 \le j \le m\)) and set \(a_{1, j} := a_{2, j}, a_{2, j} := a_{3, j}, \dots, a_{n, j} := a_{1, j}\) simultaneously.
Example of cyclic shift of the first column You want to perform the minimum number of moves to make this matrix look like this:
In other words, the goal is to obtain the matrix, where \(a_{1, 1} = 1, a_{1, 2} = 2, \dots, a_{1, m} = m, a_{2, 1} = m + 1, a_{2, 2} = m + 2, \dots, a_{n, m} = n \cdot m\) (i.e. \(a_{i, j} = (i - 1) \cdot m + j\)) with the minimum number of moves performed.
The first line of the input contains two integers \(n\) and \(m\) (\(1 \le n, m \le 2 \cdot 10^5, n \cdot m \le 2 \cdot 10^5\)) — the size of the matrix.
The next \(n\) lines contain \(m\) integers each. The number at the line \(i\) and position \(j\) is \(a_{i, j}\) (\(1 \le a_{i, j} \le 2 \cdot 10^5\)).
Print one integer — the minimum number of moves required to obtain the matrix, where \(a_{1, 1} = 1, a_{1, 2} = 2, \dots, a_{1, m} = m, a_{2, 1} = m + 1, a_{2, 2} = m + 2, \dots, a_{n, m} = n \cdot m\) (\(a_{i, j} = (i - 1)m + j\)).
3 3
3 2 1
1 2 3
4 5 6
6
4 3
1 2 3
4 5 6
7 8 9
10 11 12
0
3 4
1 6 3 4
5 10 7 8
9 2 11 12
2
首先将问题分解，要使整个矩阵满足要求，我们使矩阵的每一列满足要求即可，下面求解每一列对应的最少步数，我们需要保证结果的正确行所以每一列的所有元素都要考虑，以第一列为例子，我们用cnt数组表示每个循环移位计算不用替换的元素个数，所以每进行一次移位我们需要的操作次数为n-cnt[i]+i，记为cur，我们只需要找到每一列cur的最小值并把它累加到ans上就可以求解这个问题。
AC代码:
#include <bits/stdc++.h>
using namespace std;
const int maxn=200001;
//int mp[maxn][maxn];
//int cnt[maxn];
int main()
{
int n,m;
scanf("%d %d",&n,&m);
vector<vector<int> > mp(n, vector<int>(m));
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
scanf("%d",&mp[i][j]);
mp[i][j]--;
}
}
long long ans=0;
for(int j=0;j<m;j++)
{
vector<int> cnt(n);
//memset(cnt,0,sizeof(cnt));
for(int i=0;i<n;i++)
{
if(mp[i][j] % m == j)
{
int pos = mp[i][j] / m;
if(pos<n)
{
cnt[(i-pos+n)%n]++;
}
}
}
int cur = n-cnt[0];
for(int i=1; i<n; i++)
{
cur = min(cur, n - cnt[i] + i);
}
ans+=cur;
}
printf("%lld\n",ans);
//cout << "Hello world!" << endl;
return 0;
}
# Codeforces Round #615 (Div. 3)
标签：col contains examples 相关 operation 替换 angular 次数 with
原文地址：https://www.cnblogs.com/zdy1214/p/12237065.html
