2024牛客多校1

A  A Bit Common

考虑用组合数学去做

每个序列有n个数，从n中取出k个数，使其组成的子序列的AND 为 1

这k个数的二进制最低位必然都是1，其余n-k个数的二进制最低位必然是0（避免出现重复计算的情况）

为了使子序列的AND 为1，二进制位中，除了最低位之外的所有位，必然存在k个数中至少一个数的该位为0，如下图所示：

对于每一行（每个二进制位），满足至少一个数在该位的值为0的组合个数即为全部可能的组合个数-k个数该位全为1的情况，即为（每位均可以选择0 OR 1）

一共有m-1列，每行的情况都是相互独立的，则子序列的组合个数为

对于n-k个数，只需保证最低二进制位为0即可，组合个数为

最终答案即为，

因为题目给的模数q可能不为质数，不能用inv求组合数

code：

it n, m, mod;
it c[5000+5][5000+5];
int qsm(int a, int b){
	int ans = 1;
	if (a == 0) return 0;
	a %= mod;
	for (; b; b >>= 1){
		if (b & 1)
			ans = 1ll * ans * a % mod;
		a = 1ll * a * a % mod;
	}
	return ans % mod;
}
void init() {
	it i, j, k;
	for (i = 0; i <= n; i++)
		c[i][0] = 1;
	for (j = 1; j <= n; j++)	{
		for (i = 1; i <= n; i++) {
			c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
			c[i][j] %= mod;
		}
	}
}
void solve() {
	cin >> n >> m >> mod;
	init();
	it ans = 0;
	for (it i = 1; i <= n; i++) {
		it pn = 1;
		pn = (c[n][i] % mod);
		pn = (pn * qsm(2, (n - i) * (m - 1) % mod) % mod * qsm(qsm(2, i) - 1, m - 1) % mod) % mod;
		ans = (ans + pn) % mod;
	}
	cout << (ans + mod) % mod << '\n';
}

I Mirror Maze

光线经过镜子反射后形成的光路，为一个环或是一条链

用一个三维数组a[n][m][4]记录每个点对于从上下左右四个方向射来的光，从当前点开始，经过的反射光线的镜子的个数

如果是一条链，最终必然会从四边射入，再从四边射出。遍历四边上的所有点，作为光线的起点，向里面射入，dfs模拟光线的路线，记录经过的反射光线的点，直到射出，更新经过的所有点的a[i][j][p]的值，p为在该位置光线射来的方向。

对于所有链中均没有遍历到的某个点的射向方向，则该光路必然形成环，对所有环dfs模拟光线的路线，记录经过的反射光线的点，直到回到环的起点，更新经过的所有点的a[i][j][p]的值

对于每个询问，O（1）回答

code：

vector<string> ch(maxn);
int n, m, ans[maxn][maxn][4];
int vis[maxn][maxn][4];
vector<tii> vec;
bool istan(int x, int y, int dir) {  // 标记某个状态是否有经过镜子的反射
    char tem = ch[x][y];
    if (tem == '/' || tem == '\\')
        return 1;
    if (tem == '-' && (dir == 0 || dir == 1))
        return 1;
    if (tem == '|' && (dir == 2 || dir == 3))
        return 1;
    return 0;
}
void dfs(int x, int y, int dir) {
    if (x < 1 || x > n || y < 1 || y > m)
        return;
    if (vis[x][y][dir])
        return;
    vec.push_back(tii(x, y, dir));
    vis[x][y][dir] = 1;
    if (ch[x][y] == '/') {
        if (dir == 0) 
            dfs(x, y + 1, 3);
        else if (dir == 1) 
            dfs(x, y - 1, 2);
        else if (dir == 2) 
            dfs(x + 1, y, 1);
        else 
            dfs(x - 1, y, 0);
    }
    else if (ch[x][y] == '\\') {
        if (dir == 0) 
            dfs(x, y - 1, 2);
        else if (dir == 1) 
            dfs(x, y + 1, 3);
        else if (dir == 2) 
            dfs(x - 1, y, 0);
        else 
            dfs(x + 1, y, 1);
    }
    else if (ch[x][y] == '-') {
        if (dir == 0) 
            dfs(x + 1, y, 1);
        else if (dir == 1) 
            dfs(x - 1, y, 0);
        else if (dir == 2) 
            dfs(x, y - 1, 2);
        else
            dfs(x, y + 1, 3);
    }
    else if (ch[x][y] == '|') {
        if (dir == 0)
            dfs(x - 1, y, 0);
        else if (dir == 1)
            dfs(x + 1, y, 1);
        else if (dir == 2) 
            dfs(x, y + 1, 3);
        else 
            dfs(x, y - 1, 2);
    }
}
void solve1(int x, int y, int dir) {        //lian
    vec.clear();
    dfs(x, y, dir);
    reverse(all(vec)); 
    set<pii> s;
    for (auto u : vec) {
        int a, b, c;
        tie(a, b, c) = u;
        if (istan(a, b, c))
            s.insert(pii(a, b));
        ans[a][b][c] = s.size();
    }
}
void solve2(int x, int y, int dir) {        //huan
    vec.clear();
    dfs(x, y, dir);
    set<pii> s;
    for (auto u : vec) {
        int a, b, c;
        tie(a, b, c) = u;
        if (istan(a, b, c))
            s.insert(pii(a, b));
    }
    for (auto u : vec){
        int a, b, c;
        tie(a, b, c) = u;
        ans[a][b][c] = s.size(); 
    }
}
void solve() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++){
        cin >> ch[i];
        ch[i] = ' ' + ch[i];
    }
    for (int i = 1; i <= n; i++)
        solve1(i, 1, 3), solve1(i, m, 2);
    for (int j = 1; j <= m; j++)
        solve1(1, j, 1), solve1(n, j, 0);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            for (int k = 0; k < 4; k++)
                if (!vis[i][j][k]) 
                    solve2(i, j, k);
    int q;
    cin >> q;
    map<string, int> mp;
    mp["above"] = 0;
    mp["below"] = 1;
    mp["left"] = 2;
    mp["right"] = 3;
    while (q--) {
        int x, y;
        string str;
        cin >> x >> y >> str;
        int tem = mp[str];
        if (tem == 0)
            x--;
        else if (tem == 1)
            x++;
        else if (tem == 2)
            y--;
        else
            y++;
        cout << ans[x][y][tem] << "\n";
    }
}