B. Binary Tree
给你一棵树,两个人每次只能移走一颗子树,这个子树必须是满二叉树(叶子也行),第一个人先开始,谁不能操作谁就输了,问你谁能赢。
满二叉树是奇数个节点((2^x-1)),那么每次都是移走奇数个点,判奇偶性就行了。
D. Defining Labels
进制转换,把给的数的10进制转化为带限制k进制,每一位都要在原本认知的基础上-1。
以k=10为例:
x = 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (十进制)
0 1 2 3 4 5 6 7 8 9 00 01 02 03 04 (十进制每一位还要-1)
如果要满足每一位-1,上面9和10是对应的,如果对每一位-1,那么10第一位-1就要把第二位退一位下来;如果先转10进制再模拟减法退位应该是可行的,代码量也应该不会很大。
还有一种做法是:
void solve(int k, int x)
{
if (!x)return;
x--;
solve(k, x / k);
ans.push_back((x % k) + 10 - k);
}
假设x=114514,k=5,我们虽然不知道x的5进制表示,但如果x的五进制表示的最后一位为0时,把x--之后它的五进制也自动进行了退位,不为0时就是最后一位-1,这样x%k得到的就是最后一位的位权,那么再把这个x/=k,相当于把x右移一位,这样递归下去直到x==0时就把x分解完了w
最后再加上题目条件10-k即可。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
#define ll long long
#define pii pair<int,int>
#define fastio ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
ll mod = 1e9 + 7;
vector<int>ans;
void solve(int k, int x)
{
if (!x)return;
x--;
solve(k, x / k);
ans.push_back((x % k) + 10 - k);
}
int main()
{
fastio;
int t;
cin >> t;
while (t--)
{
ans.clear();
ll k, x;
cin >> k >> x;
solve(k, x);
for (auto i : ans)
cout << i;
cout << endl;
}
return 0;
}
E. Erasing Numbers
给长度为n的排列,每次操作选择连续的3个数,然后删除最大的和最小的数,进行很多次最终留下一个数。问你这个排列中哪些数可以在进行某一系列操作之后留下来。
记当前的数为x,比它大的数变为1,比它小的数变为0,比较0和1的个数:
①如果0和1的个数相同,那么肯定可以让这个数最终留下来(给出一种示例操作:由于0和1的个数相同,那么每次操作最理想的就是移除一个0一个1。出现0x1和1x0时移除x两侧的0和1;剩下的情况全部枚举出来:000、111、011、100、。。。操作一个000时肯定要对应的操作一个111,不过大部分时候连续0周围都会有1,这样就可以满足移除一个0一个1,连续1同理)
②如果0和1的个数不同,那么就要把多出来的数删除。由于只存在两种删除模式(删除2个相同的数(3个连续相同的数可以这样)和各删除一个),很显然只能去寻找删除2个相同的数这种情况。
让cnt0和cnt1做差,如果为奇数就凑不出来;
否则就再里面找连续的去删,看看能不能删到0和1的数量相同的状态,再去用各减1的操作处理。
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define fastio ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
const int inf = 1e9 + 7;
const ll lnf = 1e18 + 7;
const int maxn = 1e6 + 10;
ll mod = 998244353;
bool ans[maxn];
int n;
int solve(int x,vector<int>&a)
{
int cnt = 0, tot = 0;
for (int i = 1; i <= n; i++)
if (a[i] > a[x])cnt++;
else if (a[i] < a[x])tot++;
if (cnt == tot)return 1;
if (abs(cnt - tot) & 1)return 0;
int flag = (cnt > tot ? 1 : -1);
int sum = 0;
for (int i = 1; i <= n; i++)
{
if (i == x)
{
sum = 0;
continue;
}
if (a[i] > a[x])
sum += flag;
else sum -= flag;
if (sum < 0)
sum = 0;
if (sum == 3)
{
if (flag == 1)
cnt -= 2;
else tot -= 2;
sum = 1;
if (cnt == tot)
return 1;
}
}
return 0;
}
int main()
{
fastio;
int t;
cin >> t;
while (t--)
{
cin >> n;
vector<int>a(n + 1);
for (int i = 1; i <= n; i++)
cin >> a[i], ans[i] = 0;
for (int i = 1; i <= n; i++)
ans[i] = solve(i, a);
for (int i = 1; i <= n; i++)
cout << ans[i] << "";
cout << endl;
}
return 0;
}
G. Game Design
构造一棵树,每个点可以安排一个权值,选择它获得权值并覆盖它可以到达的所有叶子节点。需要构造的这棵树有k种权值和最小的选择方式选择一些点覆盖所有的叶子节点。
在纸上画画可以发现一个规律,对于两棵树,把他们连向一个构造根,操作数相乘,当这个根的权值等于两棵树所有叶子节点的权值和时操作数再+1,否则不加。(说简单一点就是子树合并满足乘法原理,连向的根需要权值特判)
可以想到一个数可以被这种方式分解:(117 = 116 + 1 = (58 * 2) + 1 =(29 * 2 * 2) + 1 = ((28 + 1) * 2 * 2) + 1) .......
每次+1可以构造新根连向上一个构造根,*2可以把一个大小为2的链连向当前构造根。
最后把叶子节点的所有权值赋为1,跑一遍dfs统计一下各个非叶子节点的权值。
如果k一开始就是偶数那么这棵树的root可以赋个无限大权值就不用-1了。
由于这个数只有1e9,大概质因数分解也可以构造,k更大一些出现大质数就不能质因数分解了。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
#define ll long long
#define pii pair<int,int>
#define fastio ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
ll mod = 1e9 + 7;
int c[maxn], fa[maxn];
vector<int>G[maxn];
int dfs(int from)
{
int res = G[from].empty();
for (auto to : G[from])
res+=dfs(to);
return c[from] = res;
}
int main()
{
fastio;
int k;
cin >> k;
int K = k;
if (k == 1)
{
cout << 2 << endl;
cout << 1 << endl;
cout << 10000 << " " << 1 << endl;
return 0;
}
c[1] = (k & 1 ? 1 : 1e8);
if (k & 1)
k--;
int cnt = 1;
int last = 1;
int tot = 1;
while (k > 1)
{
while (k % 2 == 0)
{
++cnt;
G[last].push_back(cnt);
fa[cnt] = last;
++cnt;
G[cnt - 1].push_back(cnt);
fa[cnt] = cnt - 1;
k /= 2;
}
if (k == 1)
break;
k--;
++cnt;
G[last].push_back(cnt);
fa[cnt] = last;
last = cnt;
}
dfs(1);
if (K % 2 == 0)
c[1] = 1e8;
cout << cnt << endl;
for (int i = 2; i <= cnt; i++)
cout << fa[i] << " ";
cout << endl;
for (int i = 1; i <= cnt; i++)
cout << c[i] << " ";
return 0;
}
J. Junior Mathematician
让你求L到R区间内满足条件的在模m意义下的x同余f(x)的x的个数。
f(x)的定义:
这个式子含义就是:累加每一位的贡献,它的贡献就是它的权值乘上len到上一位的前缀和。
以下为设计状态的过程,WA+TLE了一上午
很显然是数位dp,最开始想dp[pos][limit][][],后两维表示pos到len所有位的和、所有位累加的f(x),然后发现记录前缀和相同的状态它们所对应的前面一段x对m取模可能不同,故又加上一维,然后爆空间了。
然后发现(f(x)equiv x(mod m))可以变成(f(x)-x equiv 0(mod m)),这样后面又只需要两维:对于当前位置pos,第一维是pos到len这一段x对m取模的权值,第二维是pos到len这一段f(x)-x的权值(要+m %m弄成正的)。
第一维我尝试去用
(X * 10 + i) % m
去取前缀模,发现是错的,因为这种取模方式得到的结果要跑完整个长度才是正确的(后面很多个*10都没有累乘到前面去取模)
需要先去打一个表,把每一位需要乘多少个10记录下来:
for (int i = 1; i < max(s.length(), p.length()); i++)
biao[i] = biao[i - 1] * 10 % m;
导致TLE35的原因之一,计算多了,形参多了:
最后就是ac代码,这个题目卡常,不该取模的地方不要取模,函数的形参能少开就少开:
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define fastio ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
const int inf = 1e9 + 7;
const ll lnf = 1e18 + 7;
const int maxn = 1e6 + 10;
int mod = 1e9 + 7;
int m;
int dp[5005][65][65];
int biao[5050];
int len = 0, b[5050];
int dfs(int pos, int flag, int res, int sum)
{
if (pos == -1)
return res == 0;
if (!flag && ~dp[pos][sum][res])return dp[pos][sum][res];
int r = flag ? b[pos] : 9;
ll tmp = 0;
for (int i = 0; i <= r; i++)
tmp += dfs(pos - 1, flag && i == b[pos], ((res + sum * i - i * biao[pos]) % m + m) % m, (sum + i) % m);
tmp %= mod;
if (!flag)
return dp[pos][sum][res] = tmp;
else
return tmp;
}
void init(int len)
{
//memset(dp, -1, sizeof(dp));
for (int i = 0; i < len; i++)
for (int k = 0; k < m; k++)
for (int l = 0; l < m; l++)
dp[i][k][l] = -1;
}
int main()
{
fastio;
int t;
cin >> t;
biao[0] = 1;
while (t--)
{
string s, p;
cin >> s >> p >> m;
for (int i = 1; i < max(s.length(), p.length()); i++)
biao[i] = biao[i - 1] * 10 % m;
int ok = 0;
for (int i = s.length() - 1; i >= 0; i--)
{
if (s[i] == '0')
s[i] = '9';
else
{
s[i] --;
break;
}
}
if (s[0] == '0')ok = 1;
len = 0;
init(max(s.length(), p.length()));
for (int i = s.length() - 1; i >= ok; i--)
b[len++] = s[i] - '0';
int res1 = dfs(len - 1, 1, 0, 0);
len = 0;
for (int i = p.length() - 1; i >= 0; i--)
b[len++] = p[i] - '0';
int res2 = dfs(len - 1, 1, 0, 0);
cout << (res2 - res1 + mod) % mod << "
";
}
return 0;
}