Codeforces Round #701 (Div. 2) 2/12

比赛连接

T1

给出a，b两个数字。你有两种可以选择的操作。

1. 操作$a=\lfloor \frac{a}{b}\rfloor$
2. $b=b+1$

数据范围在$10^9$中，问你最少需要操作几次可以把$a$变成0。
通过思考，我们知道如果我们最终把b变成了某一个数，使得a变为0，那么我们在一开始就把b一直累加到需要的结果一定是最优解。因为这样就可以先除一个比较大的数。那么我们知道当$b!=1$时，如果b是2只需要大概30次除法就可以把a变成0。所以我们就枚举把b增加多少这个步骤就行了。

#include <bits/stdc++.h>
using namespace std;
#define js ios::sync_with_stdio(false);cin.tie(0); cout.tie(0)
#define all(__vv__) (__vv__).begin(), (__vv__).end()
#define endl "\n"
#define pai pair<int, int>
#define ms(__x__,__val__) memset(__x__, __val__, sizeof(__x__))
#define rep(i, sta, en) for(int i=sta; i<=en; ++i)
#define repp(i, sta, en) for(int i=sta; i>=en; --i)
typedef long long ll; typedef unsigned long long ull; typedef long double ld;
inline ll read() { ll s = 0, w = 1; char ch = getchar(); for (; !isdigit(ch); ch = getchar()) if (ch == '-') w = -1; for (; isdigit(ch); ch = getchar())	s = (s << 1) + (s << 3) + (ch ^ 48); return s * w; }
inline void print(ll x, int op = 10) { if (!x) { putchar('0'); if (op)	putchar(op); return; }	char F[40]; ll tmp = x > 0 ? x : -x;	if (x < 0)putchar('-');	int cnt = 0;	while (tmp > 0) { F[cnt++] = tmp % 10 + '0';		tmp /= 10; }	while (cnt > 0)putchar(F[--cnt]);	if (op)	putchar(op); }
inline ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll qpow(ll a, ll b) { ll ans = 1;	while (b) { if (b & 1)	ans *= a;		b >>= 1;		a *= a; }	return ans; }	ll qpow(ll a, ll b, ll mod) { ll ans = 1; while (b) { if (b & 1)(ans *= a) %= mod; b >>= 1; (a *= a) %= mod; }return ans % mod; }
const int dir[][2] = { {0,1},{1,0},{0,-1},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1} };
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 7;

ll n, m;

int calc(int x, int y) {
	if (y == 1)	return INF;
	int cnt = 0;
	while (x) {
		++cnt;
		x /= y;
	}
	return cnt;
}

void solve() {
	n = read(), m = read();
	int ans = INF;
	rep(i, 0, 30) {
		int tmp = calc(n, m + i);
		ans = min(ans, tmp + i);
	}
	print(ans);
}

int main() {
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	int T = read();	while (T--)
		solve();
	return 0;
}

T2

给出长度为k的最小全排列，也就是1，2，3…k，里面的一个长度为n的子序列。
并且给出m次查询。每次查询给出一个区间$[l_i,r_i]$，你要使得这个区间仍然还可以成为这个长度为k的最小的全排列的一个长度为$r_i-l_i+1$的子序列，但是还要保证这个子序列中和之前原先选择的子序列只有一个位置不同。
$1\le n,m\le 10^5,k\le 10^9$

我们只能挑选一个地方进行替换，那么我们尝试枚举全部替换的可能地点。

1. 如果我们选择最左端的进行替换，并且保证$x<a_{l_i}$，那么我们可以替换的个数就是$a_{l_i}-1$个。只能选比他还小的替换进去。
2. 如果我选择最右端的进行替换，并且保证$x>a_{r_i}$，同理我们可以替换的个数就是$k-a_{r_i}$个，我们只能选取比他大的放进去。
3. 如果我们选取了夹在他们中间的位置进行替换，也就是$a_{l_i}<x<a_{r_i}$。我们首先考虑如果选取了一样的元素，是不是这个元素不能返回原来的位置，如果放回去了就相当于没换嘛，要么放前面要么放后面，但是这样一做，你就会发现你必须进行两次替换，因为他把别人本来在的位置占掉了。所以选择相同的元素是不存在替换可能的。
4. 如果我们选择的是区间中没有出现过的元素。比如区间1,2,4,5。我们验证一下我们选取2，4都不存在替换位置，那么如果选择3，我们发现它可以放在这个区间某个点的左右两边。如1,2,3,5和1,3,4,5两种，那么对称的答案就是区间中没出现过的数的两倍。

const int N = 1e6 + 7;
 
ll n, m, k;
ll a[N];
void solve() {
	n = read(), m = read(), k = read();
	rep(i, 1, n)	a[i] = read();
	while (m--) {
		int l = read(), r = read();
		int ans = (k - a[r]) + (a[l] - 1) + 2 * (a[r] - a[l] + 1 - (r - l + 1));
		print(ans);
	}
}

T3

给出x和y，$1\le a\le x,1\le b\le y$。求满足$\lfloor \frac{a}{b}\rfloor =a\%b$的（a，b）对数。
$1\le x,y\le 10^9$

我们可以化简这个式子，把它写成$a=b\ast k+k$，既余数和倍数相同。
我们还会得到$a=(b+1)\ast k$，同时我们可以知道，如果$a\%b=k$的话，是有$b>k$这个结论的。不然取模运算是永远得不到这样的结果的。我们就可以把式子进一步化简，得到最大的k需要满足$$x\le (k+2)\ast k$$
那么我们就可以$O(\sqrt{n})$模拟这个k，去找满足条件的对应的b的取值了。

void solve() {
	x = read(), y = read(); // a = b*k + k
	ll ans = 0;
	for (ll k = 1; k * (k + 2) <= x; ++k) {
		ll mini = k + 1;
		ll maxi = min(y, x / k - 1);
		if (maxi >= mini)	ans += maxi - mini + 1;
	}
	print(ans);
}

T4

给出起始的$n\ast m$的矩阵，并且矩阵中元素$1\le a_{i,j}\le 16$，现在要你求出一个新的矩阵b，b中全部元素都是原来的倍数，并且b中相邻元素的差值必须是某个整数的四次方。输出要求$1\le b_{i,j}\le 10^6$。
$1\le n,m\le 500$

观察矩阵中全部元素的大小都不会超过16，我们要全部的数都是某个数的倍数，那么我们直接看看1到16的全部的数最小公倍数是多少，发现是$7\ast 10^5$，设置的如此巧妙，一定也就是有点关系了，我们通过这样的设计可以满足输出小于等于$10^6$以及倍数关系，接下来只需要在一定限度中，满足题目给的第二个要求，那么就按照国际象棋分黑白格，黑格保持1到16的最小公倍数，白格全部元素都加上原先数的四次方，就完美搞定了。

const int N = 500 + 7;
 
ll n, m;
int mp[N][N];
 
void solve() {
	n = read(), m = read();
	rep(i, 0, n - 1)
		rep(j, 0, m - 1)	mp[i][j] = read();
	int ans = 1;
	rep(i, 1, 16)	ans = ans / gcd(ans, i) * i;
	rep(i, 0, n - 1) {
		rep(j, 0, m - 1) {
			if ((i + j) & 1)	print(ans, 32);
			else print(ans + qpow(mp[i][j], 4), 32);
		}
		puts("");
	}
}