text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int dp[42][42][42][42];
int acc[42][42], arr[42][42];
int beut[42][42][42][42];
int sx[] = {-1, 0, -1};
int sy[] = {0, -1, -1};
int solve(int i1, int j1, int i2, int j2) {
if (i2 < i1 || j2 < j1) return 0;
int &ret = dp[i1][j1][i2][j2];
if (ret != -1) return ret;
ret = 0;
ret += beut[i1][j1][i2][j2];
for (int i = 0; i < 2; i++) ret += solve(i1, j1, i2 + sx[i], j2 + sy[i]);
ret -= solve(i1, j1, i2 + sx[2], j2 + sy[2]);
return ret;
}
int main() {
cin >> n >> m >> q;
n++;
m++;
string s;
for (int i = 1; i < n; i++) {
cin >> s;
for (int j = 1; j < m; j++) {
arr[i][j] = s[j - 1] - '0';
}
}
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++) {
acc[i][j] = acc[i - 1][j] + acc[i][j - 1] - acc[i - 1][j - 1] + arr[i][j];
}
for (int i1 = 1; i1 < n; i1++)
for (int i2 = i1; i2 < n; i2++)
for (int j1 = 1; j1 < m; j1++)
for (int j2 = j1; j2 < m; j2++) {
int sum = acc[i2][j2] + acc[i1 - 1][j1 - 1] - acc[i2][j1 - 1] -
acc[i1 - 1][j2];
if (sum == 0) {
beut[i1][j1][i2][j2] = 1;
}
}
memset(dp, -1, sizeof dp);
int a2, a1, b1, b2;
for (int i1 = 1; i1 < n; i1++)
for (int i2 = i1; i2 < n; i2++)
for (int j1 = 1; j1 < m; j1++)
for (int j2 = j1; j2 < m; j2++) solve(i1, j1, i2, j2);
for (int i = 0; i < q; i++) {
cin >> a1 >> b1 >> a2 >> b2;
long long ret = 0;
for (int i = a1; i <= a2; i++)
for (int j = b1; j <= b2; j++) ret += dp[i][j][a2][b2];
cout << ret << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
struct X {
int dig[256];
X() {
for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
dig['-'] = 1;
}
};
static X fuck;
int s = 1, v = 0, c;
for (; !fuck.dig[c = getchar()];)
;
if (c == '-')
s = 0;
else if (fuck.dig[c])
v = c ^ 48;
for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
;
return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
if (b < a) a = b;
}
const int maxn = 100005;
char mat[64][64];
int ps[64][64];
int tree[64][64][64];
int tree1[64][64][64][64];
int ps_tree[64][64][64];
int ps_tree1[64][64][64][64];
int main() {
const int n = Rint(), m = Rint(), q = Rint();
for (int i = 1; i <= n; ++i) scanf("%s", mat[i] + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) ps[i][j] = ps[i][j - 1] + (mat[i][j] == '0');
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) ps[i][j] += ps[i - 1][j];
for (int i = 1; i <= n; ++i)
for (int ii = i; ii <= n; ++ii) {
for (int jj = 1; jj <= m; ++jj) {
for (int j = 1; j <= jj; ++j) {
int total = ps[ii][jj];
total -= ps[ii][j - 1];
total -= ps[i - 1][jj];
total += ps[i - 1][j - 1];
int should = (ii - i + 1) * (jj - j + 1);
if (total != should) continue;
++tree[i][ii][jj];
++tree1[i][ii][jj][j];
}
for (int j = 1; j <= jj; ++j)
tree1[i][ii][jj][j] += tree1[i][ii][jj][j - 1];
}
for (int jj = 1; jj <= m; ++jj) tree[i][ii][jj] += tree[i][ii][jj - 1];
if (ii > i) {
for (int jj = 1; jj <= m; ++jj) tree[i][ii][jj] += tree[i][ii - 1][jj];
for (int jj = 1; jj <= m; ++jj)
for (int j = 1; j <= jj; ++j)
tree1[i][ii][jj][j] += tree1[i][ii - 1][jj][j];
}
}
for (int i = 1; i <= n; ++i)
for (int ii = 1; ii <= n; ++ii)
for (int j = 1; j <= m; ++j) {
ps_tree[i][ii][j] = ps_tree[i - 1][ii][j] + tree[i][ii][j];
}
for (int i = 1; i <= n; ++i)
for (int ii = 1; ii <= n; ++ii)
for (int jj = 1; jj <= m; ++jj)
for (int j = 1; j <= jj; ++j) {
ps_tree1[i][ii][jj][j] =
ps_tree1[i - 1][ii][jj][j] + tree1[i][ii][jj][j];
}
for (int i = 0; i < q; ++i) {
int a = Rint(), b = Rint(), c = Rint(), d = Rint();
int ans = 0;
ans += ps_tree[c][c][d] - ps_tree[a - 1][c][d] -
(ps_tree[c][c][b - 1] - ps_tree[a - 1][c][b - 1]);
for (int j = b; j <= d; ++j)
ans = ans - ps_tree1[c][c][j][b - 1] + ps_tree1[a - 1][c][j][b - 1];
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int ans[50][50][50][50], n, m, q;
char mat[50][50];
bool vis[50][50];
int calc(int a, int b, int c, int d) {
for (int i = c; i <= a; i++)
for (int j = d; j <= b; j++) vis[i][j] = 1 - (mat[i][j] - '0');
for (int i = a; i >= c; i--)
for (int j = b - 1; j >= d; j--) vis[i][j] = vis[i][j] & vis[i][j + 1];
for (int j = b; j >= d; j--)
for (int i = a - 1; i >= c; i--) vis[i][j] = vis[i][j] & vis[i + 1][j];
int cnt = 0;
for (int i = c; i <= a; i++)
for (int j = d; j <= b; j++) cnt += vis[i][j];
return cnt;
}
void fill() {
memset(ans, 0, sizeof(ans));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
ans[i][j][i][j] = 1 - (mat[i][j] - '0');
for (int a = i; a <= n; a++) {
for (int b = j; b <= m; b++) {
if (a == i && b == j) continue;
ans[i][j][a][b] += ans[i][j][a - 1][b] + ans[i][j][a][b - 1] -
ans[i][j][a - 1][b - 1] + calc(a, b, i, j);
}
}
}
}
}
void solve() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> mat[i][j];
fill();
int a, b, c, d;
while (q--) {
cin >> a >> b >> c >> d;
cout << ans[a][b][c][d] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
;
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char grid[40][41];
bool isgood[50][50][50][50];
int sum[50][50][50][50];
int dp[50][50][50][50], newdp[50][50][50][50], n, m;
int solve(int i1, int j1, int i2, int j2) {
if (i1 >= n || j1 >= m || i2 < 0 || j2 < 0 || i1 > i2 || j1 > j2) return 0;
if (dp[i1][j1][i2][j2] != -1) return dp[i1][j1][i2][j2];
int ret = isgood[i1][j1][i2][j2];
for (int k = 0; k < 2; k++)
for (int l = 0; l < 2; l++)
for (int u = 0; u < 2; u++)
for (int v = 0; v < 2; v++) {
if (!k && !l && !u && !v) continue;
if ((k + l + u + v) % 2)
ret += solve(i1 + k, j1 + l, i2 - u, j2 - v) +
solve(i1 + k, j1 + l, i2 - u, j2 - v) -
solve(i1 + k, j1 + l, i2 - u, j2 - v);
else
ret -= solve(i1 + k, j1 + l, i2 - u, j2 - v) +
solve(i1 + k, j1 + l, i2 - u, j2 - v) -
solve(i1 + k, j1 + l, i2 - u, j2 - v);
}
return dp[i1][j1][i2][j2] = ret;
}
int main() {
int q, r1, r2, c1, c2;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) scanf("%s", grid[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = i; k >= 0; k--)
for (int l = j; l >= 0; l--) {
sum[k][l][i][j] = sum[k][l + 1][i][j] + sum[k + 1][l][i][j] -
sum[k + 1][l + 1][i][j] + (grid[k][l] - '0');
if (!sum[k][l][i][j]) isgood[k][l][i][j] = 1;
}
memset(dp, -1, sizeof(dp));
dp[0][0][n - 1][m - 1] = solve(0, 0, n - 1, m - 1);
for (int i = 0; i < q; i++) {
scanf("%d%d%d%d", &r1, &c1, &r2, &c2);
r1--;
c1--;
r2--;
c2--;
printf("%d\n", dp[r1][c1][r2][c2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int a[44][44];
char c[44][44];
int f[44][44];
int cnt[44][44][44][44];
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> c[i][j];
a[i][j] = (c[i][j] == '1');
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) {
if (i == 0 || j == 0)
f[i][j] = 0;
else
f[i][j] = f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1] + a[i][j];
}
for (int xa = 1; xa <= n; xa++)
for (int ya = 1; ya <= m; ya++)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++) {
int sum =
f[xb][yb] - f[xa - 1][yb] - f[xb][ya - 1] + f[xa - 1][ya - 1];
cnt[xa][ya][xb][yb] = (sum == 0);
}
for (int xa = n; xa >= 2; xa--)
for (int ya = 1; ya <= m; ya++)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++) {
cnt[xa - 1][ya][xb][yb] += cnt[xa][ya][xb][yb];
}
for (int xa = 1; xa <= n; xa++)
for (int ya = m; ya >= 2; ya--)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++) {
cnt[xa][ya - 1][xb][yb] += cnt[xa][ya][xb][yb];
}
for (int xa = 1; xa <= n; xa++)
for (int ya = 1; ya <= m; ya++)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++) {
cnt[xa][ya][xb + 1][yb] += cnt[xa][ya][xb][yb];
}
for (int xa = 1; xa <= n; xa++)
for (int ya = 1; ya <= m; ya++)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++)
cnt[xa][ya][xb][yb + 1] += cnt[xa][ya][xb][yb];
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << cnt[a][b][c][d] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int n, m, q;
int g[44][44];
int cnt1[44][44][44][44], cnt2[44][44][44][44];
bool check2(int r, int c, int a, int b) {
if (r + a - 1 > n) return false;
if (c + b - 1 > m) return false;
for (int i = r; i < r + a; i++)
for (int j = c; j < c + b; j++)
if (g[i][j] == 1) return false;
return true;
}
bool check1(int r, int c, int a, int b) {
if (r - a + 1 <= 0) return false;
if (c - b + 1 <= 0) return false;
for (int i = r - a + 1; i <= r; i++)
for (int j = c - b + 1; j <= c; j++)
if (g[i][j] == 1) return false;
return true;
}
void init() {
for (int i = 1; i <= n; i++) {
int tmp[44][44][44];
for (int j = 1; j <= m; j++)
for (int a = 1; a <= n; a++)
for (int b = 1; b <= m; b++) {
tmp[j][a][b] = tmp[j - 1][a][b] + check1(i, j, a, b);
cnt1[i][j][a][b] = cnt1[i - 1][j][a][b] + tmp[j][a][b];
}
}
for (int i = 1; i <= n; i++) {
int tmp[44][44][44];
for (int j = 1; j <= m; j++)
for (int a = 1; a <= n; a++)
for (int b = 1; b <= m; b++) {
tmp[j][a][b] = tmp[j - 1][a][b] + check2(i, j, a, b);
cnt2[i][j][a][b] = cnt2[i - 1][j][a][b] + tmp[j][a][b];
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
g[i][j] = (int)(c - '0');
}
init();
while (q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int ans = 0;
for (int i = 1; i <= c - a + 1; i++)
for (int j = 1; j <= d - b + 1; j++) {
ans += cnt1[c][d][i][j] - cnt1[c][b - 1 + j - 1][i][j] -
cnt1[a - 1 + i - 1][d][i][j] +
cnt1[a - 1 + i - 1][b - 1 + j - 1][i][j];
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 43;
long long dp[N][N][N][N];
void solve() {
long long n, m, q;
cin >> n >> m >> q;
long long pre[n + 2][m + 2];
memset(pre, 0, sizeof pre);
for (long long i = 1; i <= n; ++i) {
string s;
cin >> s;
for (long long j = 1; j <= m; ++j) {
if (s[j - 1] == '0') pre[i][j] = pre[i - 1][j] + 1;
}
}
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= m; ++j) {
for (long long k = i; k <= n; ++k) {
for (long long l = j; l <= m; ++l) {
if (i != k) dp[i][j][k][l] += dp[i][j][k - 1][l];
if (j != l) dp[i][j][k][l] += dp[i][j][k][l - 1];
if (i != k && l != j) dp[i][j][k][l] -= dp[i][j][k - 1][l - 1];
long long mx = k - i + 1;
for (long long x = l; x >= j; --x) {
mx = min(mx, pre[k][x]);
dp[i][j][k][l] += mx;
}
}
}
}
};
while (q--) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
cout << dp[a][b][c][d] << '\n';
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
char x;
int m, n, q;
int s[50][50];
int f[50][50][50];
int g[50][50][50];
int dp[50][50][50][50];
int cmp[50];
int get(int x, int y, int u, int v) {
int z = (s[u][v] - s[x - 1][v] - s[u][y - 1] + s[x - 1][y - 1]);
return (z == (u - x + 1) * (v - y + 1));
}
int main() {
memset(s, 0, sizeof(s));
memset(dp, 0, sizeof(dp));
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(f));
cin >> m >> n >> q;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
cin >> x;
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + (x == '0');
}
for (int x = m; x >= 1; x--)
for (int y = n; y >= 1; y--) {
for (int i = x; i <= m; i++)
for (int j = y; j <= n; j++) {
f[y][i][j] += get(x, y, i, j);
g[y][i][j] = f[y][i][j] + g[y + 1][i][j];
}
memset(cmp, 0, sizeof(cmp));
for (int i = x; i <= m; i++)
for (int j = y; j <= n; j++) {
cmp[j] += g[y][i][j];
dp[x][y][i][j] = dp[x][y][i][j - 1] + cmp[j];
}
}
int a, b, c, d;
for (int i = 1; i <= q; i++) {
cin >> a >> b >> c >> d;
cout << dp[a][b][c][d] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 42;
int a1, b, c, d;
char a[maxN][maxN];
int n, m, q;
long long s[maxN][maxN];
long long f[maxN][maxN][maxN][maxN], g[maxN][maxN][maxN][maxN];
int val(int x1, int y1, int x2, int y2) {
int ans = s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1];
if (ans == 0)
return 1;
else
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
s[i][j] = s[i - 1][j] + s[i][j - 1] + (a[i][j] - '0') - s[i - 1][j - 1];
for (int x1 = 1; x1 <= n; x1++)
for (int y1 = 1; y1 <= m; y1++)
for (int x2 = x1; x2 <= n; x2++)
for (int y2 = y1; y2 <= m; y2++)
f[x1][y1][x2][y2] = f[x1][y1][x2 - 1][y2] + f[x1][y1][x2][y2 - 1] -
f[x1][y1][x2 - 1][y2 - 1] + (val(x1, y1, x2, y2));
for (int x2 = n; x2 >= 1; x2--)
for (int y2 = m; y2 >= 1; y2--)
for (int x1 = x2; x1 >= 1; x1--)
for (int y1 = y2; y1 >= 1; y1--)
g[x1][y1][x2][y2] = g[x1][y1 + 1][x2][y2] + g[x1 + 1][y1][x2][y2] -
g[x1 + 1][y1 + 1][x2][y2] + f[x1][y1][x2][y2];
while (q--) {
cin >> a1 >> b >> c >> d;
cout << g[a1][b][c][d] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int board[45][45];
string s;
int a, b, c, d;
int memo[45][45][45][45];
int sum[45][45];
int main() {
cin >> n >> m >> q;
for (int i = 1; i < (n + 1); i++) {
cin >> s;
for (int j = 1; j < (m + 1); j++) {
if (s[j - 1] == '1') {
board[i][j] = 1;
} else {
board[i][j] = 0;
}
}
}
for (int x1 = 1; x1 < (n + 1); x1++) {
for (int y1 = 1; y1 < (m + 1); y1++) {
for (int i = x1; i < (n + 1); i++) {
for (int j = y1; j < (m + 1); j++) {
sum[i][j] = 0;
}
}
for (int i = x1; i < (n + 1); i++) {
for (int j = y1; j < (m + 1); j++) {
if (board[i][j] == 1) {
break;
}
if (i > x1 && sum[i - 1][j] == 0) {
break;
}
sum[i][j] = 1;
}
}
for (int i = x1; i < (n + 1); i++) {
for (int j = y1 + 1; j < (m + 1); j++) {
sum[i][j] += sum[i][j - 1];
}
}
for (int i = x1 + 1; i < (n + 1); i++) {
for (int j = y1; j < (m + 1); j++) {
sum[i][j] += sum[i - 1][j];
}
}
for (int i = 0; i < (x1 + 1); i++) {
for (int j = 0; j < (y1 + 1); j++) {
for (int k = x1; k < (n + 1); k++) {
for (int l = y1; l < (m + 1); l++) {
memo[i][j][k][l] += sum[k][l];
}
}
}
}
}
}
for (int i = 0; i < (q); i++) {
cin >> a >> b >> c >> d;
cout << memo[a][b][c][d] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char x[40][40];
int fo[40][40];
int dp[40][40][40][40];
int n, m, q;
int f(int i, int j, int k, int l) {
if (i == k + 1 || j == l + 1) return 0;
if (dp[i][j][k][l] != -1) return dp[i][j][k][l];
int res = f(i + 1, j, k, l) + f(i, j + 1, k, l) - f(i + 1, j + 1, k, l);
if (x[i][j] == '0') {
int fone = 100;
for (int ii = i; ii < k + 1; ++ii) {
int lim = min(fo[ii][j], l + 1);
fone = min(fone, lim - j);
res += fone;
}
}
dp[i][j][k][l] = res;
return res;
}
int main() {
scanf(" %d%d%d ", &n, &m, &q);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf(" %c ", &x[i][j]);
memset(dp, -1, sizeof(dp));
memset(fo, -1, sizeof(fo));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
for (int k = j; k < m; ++k) {
if (x[i][k] == '1') {
fo[i][j] = k;
break;
}
}
if (fo[i][j] == -1) fo[i][j] = m;
}
for (int k = 0; k < q; ++k) {
int i1, j1, i2, j2;
scanf(" %d%d%d%d ", &i1, &j1, &i2, &j2);
i1--;
i2--;
j1--;
j2--;
printf("%d\n", f(i1, j1, i2, j2));
}
return 0;
}
|
#include <bits/stdc++.h>
char g[42][42];
int sum[41][41] = {0}, dp[41][41][41][41] = {0};
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i) scanf("%s", g[i] + 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (g[i][j] == '0') sum[i][j] = sum[i][j - 1] + 1;
}
}
for (int a = 1; a <= n; ++a)
for (int b = 1; b <= m; ++b)
for (int c = a; c <= n; ++c)
for (int d = b; d <= m; ++d) {
int l = d - b + 1;
dp[a][b][c][d] =
dp[a][b][c - 1][d] + dp[a][b][c][d - 1] - dp[a][b][c - 1][d - 1];
for (int i = c; i >= a; --i) {
if (sum[i][d] < l) l = sum[i][d];
dp[a][b][c][d] += l;
}
}
int a, b, x, y;
for (int i = 0; i < q; ++i) {
scanf("%d%d%d%d", &a, &b, &x, &y);
printf("%d\n", dp[a][b][x][y]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 1e12;
long long M = 1E9 + 7;
int MAXN = 123456;
double PI = 2 * acos(0);
int dp[45][45][45][45], v[45][45];
int z(int x) {
if (x) return 1;
return 0;
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char ch = getchar();
while (ch != '0' && ch != '1') ch = getchar();
v[i][j] =
v[i - 1][j] + v[i][j - 1] - v[i - 1][j - 1] + (ch == '1' ? 1 : 0);
}
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
for (int k = i; k <= n; k++) {
for (int l = j; l <= m; l++) {
int& sm = dp[i][j][k][l];
if ((v[k][l] + v[i - 1][j - 1] - v[i - 1][l] - v[k][j - 1]) == 0)
sm = 1;
for (int mask = 1; mask < (1 << 4); mask++) {
int f = ((__builtin_popcount(mask) & 1) ? 1 : -1);
sm += (f * dp[i + z(mask & 1)][j + z(mask & 2)][k - z(mask & 4)]
[l - z(mask & 8)]);
}
}
}
}
}
for (int i = 0; i < q; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << dp[a][b][c][d] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[41][41][41][41];
char tbl[41][41];
int len[41];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) scanf("%s", tbl[i]);
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++) {
for (int j = c; j < m; j++) len[j] = 0;
for (int i = r; i < n; i++) {
len[c]++;
if (tbl[i][c] == '1') len[c] = 0;
for (int j = c + 1; j < m; j++) {
len[j] = min(len[j - 1], len[j] + 1);
if (tbl[i][j] == '1') len[j] = 0;
}
if (i > r)
for (int j = c; j < m; j++)
dp[r][c][i][j] = dp[r][c][i - 1][j] + len[j];
else
for (int j = c; j < m; j++) dp[r][c][i][j] = len[j];
}
}
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++)
for (int i = r; i < n; i++)
for (int j = c + 1; j < m; j++) dp[r][c][i][j] += dp[r][c][i][j - 1];
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++)
for (int i = r; i < n; i++)
for (int j = c - 1; j >= 0; j--) dp[r][j][i][c] += dp[r][j + 1][i][c];
for (int i = 0; i < q; i++) {
int sr, sc, er, ec;
scanf("%d%d%d%d", &sr, &sc, &er, &ec);
printf("%d\n", dp[sr - 1][sc - 1][er - 1][ec - 1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[45][45], sum[45][45], h[45][45][45][45], ans[45][45][45][45], n, i, j, k,
d, l, m, r, t, y, x, z, u, sn, mm, p, a1, a2, a3, a4;
char c;
int summ(int I, int J, int i, int j) {
int jj = sum[i][j] - sum[I - 1][j] - sum[i][J - 1] + sum[I - 1][J - 1];
if (jj == 0)
return 1;
else
return 0;
}
int main() {
int q;
cin >> n >> m >> q;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> c;
a[i + 1][j + 1] = c - '0';
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
for (i = n; i >= 1; i--)
for (j = m; j >= 1; j--)
for (k = i; k > 0; k--)
for (l = j; l > 0; l--)
h[k][l][i][j] = summ(k, l, i, j) + h[k + 1][l][i][j] +
h[k][l + 1][i][j] - h[k + 1][l + 1][i][j];
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
for (k = i; k <= n; k++)
for (l = j; l <= m; l++)
ans[i][j][k][l] = h[i][j][k][l] + ans[i][j][k - 1][l] +
ans[i][j][k][l - 1] - ans[i][j][k - 1][l - 1];
for (i = 0; i < q; i++) {
cin >> a1 >> a2 >> a3 >> a4;
cout << ans[a1][a2][a3][a4] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[45][45][45][45];
int a[45][45];
int n, m, q;
string s;
int main() {
cin >> n >> m >> q;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> s;
a[i][0] = (s[0] == '0');
for (int j = 1; j < m; j++) {
if (s[j] == '0')
a[i][j] = 1 + a[i][j - 1];
else
a[i][j] = 0;
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int x = i; x < n; x++)
for (int y = j; y < m; y++) {
if (x > i) dp[i][j][x][y] += dp[i][j][x - 1][y];
if (y > j) dp[i][j][x][y] += dp[i][j][x][y - 1];
if (x > i && y > j) dp[i][j][x][y] -= dp[i][j][x - 1][y - 1];
int tmp = min(a[x][y], y - j + 1);
for (int k = x; k >= i; k--) {
tmp = min(a[k][y], tmp);
dp[i][j][x][y] += tmp;
}
}
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << dp[a - 1][b - 1][c - 1][d - 1] << endl;
}
}
|
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wwrite-strings"
using namespace std;
void P(int depth, char *format, ...) {
int i;
for (i = 0; i < depth; i++) printf("~~~~~~~~~~~~~~");
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
printf("\n");
}
ostream &operator<<(ostream &out, const vector<int> A) {
for (int i = 0; i < (A.size()); ++i) out << A[i] << " ";
return out;
}
ostream &operator<<(ostream &out, const vector<vector<int> > A) {
for (int i = 0; i < (A.size()); ++i) {
for (int j = 0; j < (A[i].size()); ++j) out << A[i][j] << " ";
out << endl;
}
return out;
}
template <class T>
void mini(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
void maxi(T &a, const T &b) {
if (b > a) a = b;
}
bool solve();
bool isValid(int i, int j, int k, int l, vector<vector<int> > &S) {
return S[k][l] - S[i - 1][l] - S[k][j - 1] + S[i - 1][j - 1] == 0;
}
int main() {
solve();
return 0;
}
bool solve() {
int N, M, Q;
cin >> N >> M >> Q;
vector<string> A(N);
for (int i = 0; i < (N); ++i) cin >> A[i];
vector<vector<int> > S(N + 1);
for (int i = 0; i < (N + 1); ++i) S[i].resize(M + 1);
S[1][1] = A[0][0] == '1';
for (int i = (1); i <= (N); ++i)
for (int j = (1); j <= (M); ++j)
S[i][j] = S[i - 1][j] + S[i][j - 1] - S[i - 1][j - 1] +
(A[i - 1][j - 1] == '1');
int D[N + 2][M + 2][N + 1][M + 1];
memset(D, 0, sizeof(int) * (N + 2) * (M + 2) * (N + 1) * (M + 1));
for (int i = (N); i >= (1); --i)
for (int j = (M); j >= (1); --j)
for (int k = (i); k <= (N); ++k)
for (int l = (j); l <= (M); ++l) {
int &r = D[i][j][k][l];
assert(!r);
r = isValid(i, j, k, l, S);
for (int m = (1); m <= ((1 << 4) - 1); ++m) {
r += ((__builtin_popcount(m) % 2) ? 1 : -1) *
D[i + (bool)(m & 1)][j + (bool)(m & 2)][k - (bool)(m & 4)]
[l - (bool)(m & 8)];
assert(i + (bool)(m & 1) <= N + 1);
assert(i + (bool)(m & 1) >= 0);
}
}
for (int i = 0; i < (Q); ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << D[a][b][c][d] << endl;
}
return true;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<char*> t;
vector<vector<vector<vector<int> > > > dp1(
51, vector<vector<vector<int> > >(
51, vector<vector<int> >(51, vector<int>(51, -1))));
vector<vector<vector<vector<int> > > > dp2(
51, vector<vector<vector<int> > >(
51, vector<vector<int> >(51, vector<int>(51, -1))));
inline int isaz(int x, int y, int w, int h) {
if (dp1[x][y][w][h] != -1) return dp1[x][y][w][h];
if (w > 1)
return dp1[x][y][w][h] =
isaz(x, y, w / 2, h) && isaz(x + w / 2, y, w - w / 2, h);
if (h > 1)
return dp1[x][y][w][h] =
isaz(x, y, w, h / 2) && isaz(x, y + h / 2, w, h - h / 2);
return dp1[x][y][w][h] = (t[y][x] == '0');
}
inline int nor_stupid(int x, int y, int w, int h) {
int ans = 0;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
for (int nw = 1; nw <= w - j; ++nw) {
for (int nh = 1; nh <= h - i; ++nh) {
ans += isaz(x + j, y + i, nw, nh);
}
}
}
}
return ans;
}
inline int nor(int x, int y, int w, int h) {
if (w <= 0 || h <= 0) return 0;
if (dp2[x][y][w][h] != -1) return dp2[x][y][w][h];
if (w == 1 && h == 1) return dp2[x][y][w][h] = isaz(x, y, w, h);
int ans = 0;
if (w > h) {
ans +=
nor(x, y, w - 1, h) + nor(x + 1, y, w - 1, h) - nor(x + 1, y, w - 2, h);
for (int i = 0; i < h; ++i)
for (int ih = 1; ih <= h - i; ++ih) ans += isaz(x, y + i, w, ih);
} else {
ans +=
nor(x, y, w, h - 1) + nor(x, y + 1, w, h - 1) - nor(x, y + 1, w, h - 2);
for (int i = 0; i < w; ++i)
for (int iw = 1; iw <= w - i; ++iw) ans += isaz(x + i, y, iw, h);
}
return dp2[x][y][w][h] = ans;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
t.resize(n);
for (int i = 0; i < n; ++i) {
t[i] = (char*)malloc(m + 1);
scanf("%s", t[i]);
}
for (int i = 0; i < q; ++i) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", nor(b - 1, a - 1, d - b + 1, c - a + 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 5e5 + 3;
long long row[50][50], dp[50][50][50][50];
int main() {
ios::sync_with_stdio(false);
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
char c;
cin >> c;
(c == '0') ? row[i][j] += row[i][j - 1] + 1 : 0;
}
}
for (long long a = 1; a <= n; a++)
for (long long b = 1; b <= m; b++)
for (long long c = a; c <= n; c++)
for (long long d = b; d <= m; d++) {
dp[a][b][c][d] =
dp[a][b][c - 1][d] + dp[a][b][c][d - 1] - dp[a][b][c - 1][d - 1];
long long len = d - b + 1;
for (long long i = c; i >= a; i--) {
if (len > row[i][d]) len = row[i][d];
dp[a][b][c][d] += len;
}
}
for (long long i = 1; i <= q; i++) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
cout << dp[a][b][c][d] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t, sum[41][41][41][41], g[41][41][41][41];
char s[100];
bool ok[41][41], f[41][41][41][41];
int main() {
scanf("%d%d%d", &n, &m, &t);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
for (int j = 1; j <= m; j++)
if (s[j - 1] == '0')
ok[i][j] = true;
else
ok[i][j] = false;
}
memset(f, false, sizeof(f));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ok[i][j]) f[i][j][i][j] = true;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ok[i][j]) {
for (int k = j + 1; k <= m; k++)
if (ok[i][k])
f[i][j][i][k] = true;
else
break;
for (int k = i + 1; k <= n; k++)
if (ok[k][j])
f[i][j][k][j] = true;
else
break;
for (int k = i + 1; k <= n; k++)
for (int l = j + 1; l <= m; l++)
if (f[i][j][k - 1][l] && f[i][j][k][l - 1] && ok[k][l])
f[i][j][k][l] = true;
}
memset(g, false, sizeof(g));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = i; k <= n; k++)
for (int l = j; l <= m; l++)
g[i][j][k][l] = g[i - 1][j][k][l] + g[i][j - 1][k][l] -
g[i - 1][j - 1][k][l] + f[i][j][k][l];
memset(sum, false, sizeof(sum));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = i; k <= n; k++)
for (int l = j; l <= m; l++)
sum[i][j][k][l] = sum[i][j][k - 1][l] + sum[i][j][k][l - 1] -
sum[i][j][k - 1][l - 1] + g[k][l][k][l] +
g[i - 1][j - 1][k][l] - g[k][j - 1][k][l] -
g[i - 1][l][k][l];
while (t--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", sum[a][b][c][d]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, q, x, y, xx, yy, xa, ya, xb, yb, sum[44][44], cnt[44][44][44][44];
char s[44][44];
bool isGood(int xa, int ya, int xb, int yb) {
return sum[xa][ya] - sum[xa][yb] - sum[xb][ya] + sum[xb][yb] == 0;
}
int main() {
cin >> m >> n >> q;
for (int i = 0; i < m; i++) cin >> s[i];
for (x = 0; x < m; x++)
for (y = 0; y < n; y++)
sum[x + 1][y + 1] =
sum[x + 1][y] + sum[x][y + 1] - sum[x][y] + (s[x][y] != '0' ? 1 : 0);
for (x = 0; x < m; x++)
for (y = 0; y < n; y++)
for (xx = x + 1; xx <= m; xx++)
for (yy = y + 1; yy <= n; yy++)
cnt[x][y][xx + 1][yy + 1] =
cnt[x][y][xx + 1][yy] + cnt[x][y][xx][yy + 1] -
cnt[x][y][xx][yy] + (isGood(x, y, xx, yy) ? 1 : 0);
for (int i = 0; i < q; i++) {
cin >> xa >> ya >> xb >> yb;
xa--;
ya--;
int ans = 0;
for (x = xa; x < xb; x++)
for (y = ya; y < yb; y++) ans += cnt[x][y][xb + 1][yb + 1];
cout << ans;
if (i != q - 1) cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[44][44];
int ans[44][44][44][44];
int top[44][44];
int main() {
int i, j, n, m, q, a, b, c, d, minH;
while (~scanf("%d%d%d", &n, &m, &q)) {
memset(top, 0, sizeof(top));
memset(ans, 0, sizeof(ans));
for (i = 1; i <= n; i++) {
scanf("%s", str[i] + 1);
for (j = 1; j <= m; j++) {
if (str[i][j] == '0') {
top[i][j] = top[i - 1][j] + 1;
} else {
top[i][j] = 0;
}
}
}
for (a = 1; a <= n; a++) {
for (b = 1; b <= m; b++) {
for (c = a; c <= n; c++) {
for (d = b; d <= m; d++) {
ans[a][b][c][d] = ans[a][b][c - 1][d] + ans[a][b][c][d - 1] -
ans[a][b][c - 1][d - 1];
minH = min(top[c][d], c - a + 1);
for (i = d; i >= b; i--) {
minH = min(top[c][i], minH);
if (minH == 0) {
break;
} else {
ans[a][b][c][d] += minH;
}
}
}
}
}
}
while (q--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", ans[a][b][c][d]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
int n, m, q, a, b, c, d;
char ch;
long long dps[55][55], dp[55][55][55][55];
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ch;
dps[i][j] = dps[i][j - 1] + 1;
if (ch == '1') {
dps[i][j] = 0;
}
}
}
for (int a = 1; a <= n; a++) {
for (int b = 1; b <= m; b++) {
for (int c = a; c <= n; c++) {
for (int d = b; d <= m; d++) {
dp[a][b][c][d] =
dp[a][b][c][d - 1] + dp[a][b][c - 1][d] - dp[a][b][c - 1][d - 1];
long long cnt = d - b + 1;
for (int i = c; i >= a; i--) {
cnt = min(cnt, dps[i][d]);
dp[a][b][c][d] += cnt;
}
}
}
}
}
while (q--) {
cin >> a >> b >> c >> d;
cout << dp[a][b][c][d] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long inf = 10000000;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= MOD;
(a < 0) && (a += MOD);
}
inline long long modMul(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a * b) % MOD;
}
inline long long modAdd(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
return (a + b) % MOD;
}
inline long long modSub(long long a, long long b) {
a %= MOD, b %= MOD;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, MOD - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void input(long long n, const long long a[], int co = 0) {
long long i = 1;
for (; i <= n; i++) {
}
}
const int N = 45;
int dp[N][N][N][N];
char Grid[N][N];
int cal[N][N];
int n, m, k;
void dfs() {}
bool cmp() {}
void gen() {
for (int i = int(1); i < int(n + 1); ++i)
for (int j = int(1); j < int(m + 1); ++j) {
cal[i][j] = cal[i - 1][j] + cal[i][j - 1] - cal[i - 1][j - 1] +
(Grid[i][j] == '1');
}
}
void marmarkatkat() {
for (int i = int(1); i < int(n + 1); ++i) {
for (int j = int(1); j < int(m + 1); ++j) {
for (int l = int(i); l < int(n + 1); ++l)
for (int r = int(j); r < int(m + 1); ++r)
dp[i][j][l][r] += (cal[l][r] + cal[i - 1][j - 1] - cal[i - 1][r] -
cal[l][j - 1]) == 0;
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
memset(cal, 0, sizeof cal);
;
for (int i = int(1); i < int(n + 1); ++i) {
scanf("%s", Grid[i] + 1);
}
gen();
marmarkatkat();
for (int l = int(1); l < int(n + 1); ++l) {
for (int r = int(1); r < int(m + 1); ++r) {
for (int i = int(n); i >= int(1); --i)
for (int j = int(m); j >= int(1); --j) {
dp[i][j][l][r] += (dp[i + 1][j][l][r] + dp[i][j + 1][l][r] -
dp[i + 1][j + 1][l][r]);
}
}
}
for (int l = int(1); l < int(n + 1); ++l) {
for (int r = int(1); r < int(m + 1); ++r) {
for (int i = int(n); i >= int(1); --i)
for (int j = int(m); j >= int(1); --j) {
dp[i][j][l][r] +=
dp[i][j][l - 1][r] + dp[i][j][l][r - 1] - dp[i][j][l - 1][r - 1];
}
}
}
int a, b, x, y;
for (int i = int(0); i < int(k); ++i) {
scanf("%d %d", &a, &b), scanf("%d %d", &x, &y);
;
printf("%d\n", dp[a][b][x][y]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[41][41];
int g[41][41];
int f[41][41][41][41];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++) {
if (s[i][j] == '0')
g[i][j] = g[i][j - 1] + 1;
else
g[i][j] = 0;
}
}
for (int a = 1; a <= n; a++) {
for (int b = 1; b <= m; b++) {
for (int c = a; c <= n; c++) {
for (int d = b; d <= m; d++) {
f[a][b][c][d] =
f[a][b][c][d - 1] + f[a][b][c - 1][d] - f[a][b][c - 1][d - 1];
int r = d - b + 1;
for (int e = c; e >= a; e--) {
r = min(r, g[e][d]);
f[a][b][c][d] += r;
}
}
}
}
}
while (q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", f[a][b][c][d]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a;
int b;
int c;
int d;
};
bool cmp(const node &first, const node &sec) {
if (first.a != sec.a) return first.a < sec.a;
return first.b < sec.b;
}
bool operator<(const node &left, const node &right) { return left.b > right.b; }
int ans[50][50][50][50], l[50][50];
int arr[50][50], h[50][50];
int find_ans(int i, int j, int x, int y) {
int k, s;
int miny = min(l[x][y], y - j + 1);
s = x;
while (s >= i) {
miny = min(miny, min(l[s][y], y - j + 1));
ans[i][j][x][y] += miny;
s--;
}
return 0;
}
int main() {
int n, m, q, i, j, a, b, c, d, k, ll;
char str[50];
cin >> n >> m >> q;
for (i = 1; i <= n; i++) {
cin >> str;
for (j = 1; j <= m; j++) arr[i][j] = str[j - 1] - 48;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (arr[i][j] == 1)
l[i][j] = 0;
else if (j == 1)
l[i][j] = 1;
else
l[i][j] = l[i][j - 1] + 1;
if (arr[i][j] == 1)
h[i][j] = 0;
else if (i == 1)
h[i][j] = 1;
else
h[i][j] = h[i - 1][j] + 1;
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
for (k = i; k <= n; k++) {
for (ll = j; ll <= m; ll++) {
if ((k == i) && (ll == j))
ans[i][j][k][ll] = 1 - arr[i][j];
else if (i == k) {
ans[i][j][k][ll] = ans[i][j][k][ll - 1] + min(l[k][ll], ll - j + 1);
} else if (j == ll)
ans[i][j][k][ll] = ans[i][j][k - 1][ll] + min(h[k][ll], k - i + 1);
else {
ans[i][j][k][ll] = ans[i][j][k][ll - 1] + ans[i][j][k - 1][ll] -
ans[i][j][k - 1][ll - 1];
find_ans(i, j, k, ll);
}
}
}
}
}
for (i = 1; i <= q; i++) {
cin >> a >> b >> c >> d;
cout << ans[a][b][c][d] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 400000;
const int maxn = 41;
int n, m, q, p[maxn][maxn], mn, d[maxn][maxn][maxn][maxn],
dp[maxn][maxn][maxn][maxn];
char a[maxn][maxn];
int main() {
scanf("%d%d%d\n", &n, &m, &q);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) scanf("%c", &a[i][j]);
scanf("%c", &a[i][0]);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (a[i][j] == '0') p[i][j] = p[i - 1][j] + 1;
}
for (int i1 = 1; i1 <= n; ++i1)
for (int i2 = i1; i2 <= n; ++i2)
for (int j2 = 1; j2 <= m; ++j2) {
mn = i2 - i1 + 1;
for (int j1 = j2; j1 >= 1; --j1) {
mn = min(mn, p[i2][j1]);
d[i1][i2][j1][j2] = d[i1][i2][j1 + 1][j2] + mn;
}
}
for (int i1 = 1; i1 <= n; ++i1)
for (int i2 = i1; i2 <= n; ++i2)
for (int j1 = 1; j1 <= m; ++j1)
for (int j2 = j1; j2 <= m; ++j2) {
dp[i1][i2][j1][j2] = dp[i1][i2 - 1][j1][j2];
for (int j3 = j1; j3 <= j2; ++j3)
dp[i1][i2][j1][j2] += d[i1][i2][j1][j3];
}
int i1, i2, j1, j2;
for (int i = 0; i < q; ++i) {
scanf("%d%d%d%d", &i1, &j1, &i2, &j2);
printf("%d\n", dp[i1][i2][j1][j2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50;
bool b[MAXN][MAXN];
int h[MAXN][MAXN], ans[MAXN][MAXN][MAXN][MAXN];
void calc(int sx, int sy, int ex, int ey) {
int cur = ans[sx][sy][ex - 1][ey] + ans[sx][sy][ex][ey - 1] -
ans[sx][sy][ex - 1][ey - 1];
int minh = ex - sx;
for (int i = ey - 1; i >= sy; i--) {
minh = min(minh, h[ex - 1][i]);
cur += minh;
}
ans[sx][sy][ex][ey] = cur;
}
int main() {
ios ::sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char chr;
cin >> chr;
if (b[i][j] = (chr == '0')) {
h[i][j] = 1;
if (i) h[i][j] += h[i - 1][j];
}
}
for (int sx = 0; sx < n; sx++)
for (int sy = 0; sy < m; sy++)
for (int ex = sx + 1; ex <= n; ex++)
for (int ey = sy + 1; ey <= m; ey++) calc(sx, sy, ex, ey);
for (int i = 0; i < q; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a--;
b--;
cout << ans[a][b][c][d] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 42;
int n, m, q, a[N][N], U[N][N], L[N][N];
int s[N][N][N][N];
int calc(int x) { return x * (x + 1) / 2; }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%1d", &a[i][j]);
for (int i = 1; i <= n; i++) a[i][0] = 1;
for (int i = 0; i <= m; i++) a[0][i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
while (a[i - U[i][j]][j] == 0) U[i][j]++;
while (a[i][j - L[i][j]] == 0) L[i][j]++;
}
for (int sx = 1; sx <= n; sx++)
for (int sy = 1; sy <= m; sy++)
for (int ex = sx; ex <= n; ex++)
for (int ey = sy; ey <= m; ey++) {
int &now = s[sx][sy][ex][ey];
now = s[sx][sy][ex - 1][ey - 1];
int q[N], d[N], v[N], tail = 0;
for (int i = sx; i < ex; i++) v[i] = min(L[i][ey], ey - sy + 1);
v[ex] = 0;
q[0] = 0, v[0] = 0;
for (int i = sx; i <= ex; i++) {
int dd = i;
while (tail > 0 && v[i] < v[q[tail]]) {
now += calc(i - d[q[tail]]) *
(v[q[tail]] - max(v[q[tail - 1]], v[i]));
dd = d[q[tail--]];
}
d[i] = dd;
q[++tail] = i;
}
for (int i = sy; i <= ey; i++) v[i] = min(U[ex][i], ex - sx + 1);
v[ey + 1] = tail = 0;
for (int i = sy; i <= ey + 1; i++) {
int dd = i;
while (tail > 0 && v[i] < v[q[tail]]) {
now += calc(i - d[q[tail]]) *
(v[q[tail]] - max(v[q[tail - 1]], v[i]));
dd = d[q[tail--]];
}
d[i] = dd;
q[++tail] = i;
}
}
while (q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", s[a][b][c][d]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a, b, c, d, dp[50][50][50][50], A[50][50];
string s[50];
int main() {
cin >> n >> m >> q;
for (int i = 0; i <= n - 1; i++) cin >> s[i];
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= m - 1; j++)
A[i + 1][j + 1] = (A[i + 1][j] + 1) * (s[i][j] == '0');
for (int w = 1; w <= m; w++)
for (int h = 1; h <= n; h++)
for (int i = 1; i <= n - h + 1; i++)
for (int j = 1; j <= m - w + 1; j++) {
dp[i][i + h - 1][j][j + w - 1] = dp[i][i + h - 1][j][j + w - 2] +
dp[i][i + h - 2][j][j + w - 1] -
dp[i][i + h - 2][j][j + w - 2];
for (int k = i + h - 1, C = w; k >= i; C = min(C, A[k][j + w - 1]),
dp[i][i + h - 1][j][j + w - 1] += C, k--)
;
}
for (int i = 1; i <= q; i++)
cin >> a >> b >> c >> d, cout << dp[a][c][b][d] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int sum[50][50][50][50] = {0}, numx[50][50][50][50] = {0},
numy[50][50][50][50] = {0}, g[50][50];
int main() {
int m, n, q, i, j, k, l, a, b, c, d, max, temp;
scanf("%d %d %d", &m, &n, &q);
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) {
scanf("%1d", &g[i][j]);
}
}
for (a = 1; a <= m; a++) {
for (b = 1; b <= n; b++) {
for (j = a; j <= m; j++) {
for (k = b; k <= n; k++) {
sum[a][b][j][k] = sum[a][b][j - 1][k] + sum[a][b][j][k - 1] -
sum[a][b][j - 1][k - 1];
max = 1000;
if (g[j][k]) {
numx[a][b][j][k] = 0;
numy[a][b][j][k] = 0;
} else {
numx[a][b][j][k] = numx[a][b][j - 1][k] + 1;
numy[a][b][j][k] = numy[a][b][j][k - 1] + 1;
for (l = k; l > k - numy[a][b][j][k]; l--) {
if (max > numx[a][b][j][l]) {
max = numx[a][b][j][l];
}
sum[a][b][j][k] += max;
}
}
}
}
}
}
for (i = 0; i < q; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
printf("%d\n", sum[a][b][c][d]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
int a[45][45], cnt[45][45][45][45];
int s[45][45], sum[45][45][45][45];
int main() {
int n, m, cs;
scanf("%d%d%d", &n, &m, &cs);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%1d", &a[i][j]);
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
}
for (int i = n; i >= 1; i--)
for (int j = m; j >= 1; j--)
for (int r = i; r <= n; r++)
for (int c = j; c <= m; c++) {
int dot = s[r][c] - s[r][j - 1] - s[i - 1][c] + s[i - 1][j - 1];
cnt[i][j][r][c] = cnt[i][j][r - 1][c] + cnt[i][j][r][c - 1] -
cnt[i][j][r - 1][c - 1] + !dot;
}
for (int i = n; i >= 1; i--)
for (int j = m; j >= 1; j--)
for (int r = i; r <= n; r++)
for (int c = j; c <= m; c++)
sum[i][j][r][c] = sum[i + 1][j][r][c] + sum[i][j + 1][r][c] -
sum[i + 1][j + 1][r][c] + cnt[i][j][r][c];
while (cs--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", sum[a][b][c][d]);
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int dp[50][50][50][50], dc[50][50], vis[50][50][50][50];
char s[50][50];
int check(int x, int y, int p, int q) {
return dc[p][q] - dc[p][y - 1] - dc[x - 1][q] + dc[x - 1][y - 1] == 0 ? 1 : 0;
}
int dfs(int x, int y, int p, int q) {
int &re = dp[x][y][p][q];
if (vis[x][y][p][q]) return re;
vis[x][y][p][q] = 1;
int ch = check(x, y, p, q);
if (p < x || q < y)
return 0;
else if (x == p && y == q)
return re = (s[x][y] == '0' ? 1 : 0);
else if (x == p && y != q) {
return re = dfs(x, y, p, q - 1) + dfs(x, y + 1, p, q) -
dfs(x, y + 1, p, q - 1) + ch;
} else if (x != p && y == q) {
return re = dfs(x, y, p - 1, q) + dfs(x + 1, y, p, q) -
dfs(x + 1, y, p - 1, q) + ch;
} else {
return re = ch + dfs(x, y, p - 1, q) + dfs(x + 1, y, p, q) +
dfs(x, y + 1, p, q) + dfs(x, y, p, q - 1) -
dfs(x + 1, y, p - 1, q) - dfs(x, y, p - 1, q - 1) -
dfs(x, y + 1, p - 1, q) - dfs(x + 1, y + 1, p, q) -
dfs(x + 1, y, p, q - 1) - dfs(x, y + 1, p, q - 1) +
dfs(x + 1, y + 1, p - 1, q) + dfs(x + 1, y, p - 1, q - 1) +
dfs(x, y + 1, p - 1, q - 1) + dfs(x + 1, y + 1, p, q - 1) -
dfs(x + 1, y + 1, p - 1, q - 1);
}
}
int main() {
int n, m, i, j, k, x, y, z, w, t, ca = 1, num = 0, re = 0, q;
scanf("%d%d%d", &(n), &(m), &(q));
for (int i = 0; i < (int)(n); ++i) scanf("%s", s[i]);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j) {
if (j == 0)
dc[i][j] = s[i][j] == '1' ? 1 : 0;
else
dc[i][j] = dc[i][j - 1] + (s[i][j] == '1' ? 1 : 0);
}
for (int j = 0; j < (int)(m); ++j)
for (int i = 0; i < (int)(n); ++i) {
if (i) dc[i][j] += dc[i - 1][j];
}
while (q--) {
scanf("%d%d", &(x), &(y)), scanf("%d%d", &(z), &(w));
x--, y--, z--, w--;
printf("%d\n", dfs(x, y, z, w));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 45;
int dp[MAXN][MAXN][MAXN][MAXN];
int a[MAXN][MAXN];
int n, m, q;
void compute() {
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int p = i; p <= n; p++) {
for (int q = j; q <= m; q++) {
int tmp = 0, minh = p - i + 1;
for (int y = q; y >= j; y--) {
for (int x = p; x >= i; x--) {
if (a[x][y] == 1) {
minh = min(minh, p - x);
break;
}
}
tmp += minh;
}
dp[i][j][p][q] = dp[i][j][p][q - 1] + dp[i][j][p - 1][q] -
dp[i][j][p - 1][q - 1] + tmp;
}
}
}
}
}
int main() {
while (cin >> n >> m >> q) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%1d", &a[i][j]);
}
}
compute();
for (int i = 0; i < q; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", dp[a][b][c][d]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, it, n, m, a[45][45], dp[45][45], dp1[45][45][45][45], sum, q;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> q;
for (i = 1; i <= n; ++i)
for (j = 1, cin >> s; j <= m; ++j) {
dp[i][j] = (s[j - 1] == '1');
dp[i][j] += dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1];
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
for (k = i; k <= n; ++k)
for (it = j; it <= m; ++it) {
sum = dp[k][it] - dp[i - 1][it] - dp[k][j - 1] + dp[i - 1][j - 1];
if (!sum) ++dp1[i][j][k][it];
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
for (k = i; k <= n; ++k)
for (it = j; it <= m; ++it)
dp1[i][j][k][it] += dp1[i][j][k - 1][it] + dp1[i][j][k][it - 1] -
dp1[i][j][k - 1][it - 1];
for (k = n; k > 0; --k)
for (it = m; it > 0; --it)
for (i = k; i > 0; --i)
for (j = it; j > 0; --j)
dp1[i][j][k][it] += dp1[i + 1][j][k][it] + dp1[i][j + 1][k][it] -
dp1[i + 1][j + 1][k][it];
while (q--) cin >> i >> j >> k >> it, cout << dp1[i][j][k][it] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int rec[40][40][40][40], con[40][40][40][40], r[40][40];
int main() {
int n, m, q, a, c, b, d, i, j, k, l;
string s[50];
scanf("%d %d %d", &n, &m, &q);
for (i = 0; i < n; i++) {
cin >> s[i];
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
r[i][j] = s[i][j] - '0';
}
}
rec[0][0][0][0] = r[0][0];
for (j = 1; j < m; j++) {
rec[0][0][0][j] = rec[0][0][0][j - 1] + r[0][j];
}
for (i = 1; i < n; i++) {
rec[0][0][i][0] = rec[0][0][i - 1][0] + r[i][0];
for (j = 1; j < m; j++) {
rec[0][0][i][j] = rec[0][0][i - 1][j] + rec[0][0][i][j - 1] -
rec[0][0][i - 1][j - 1] + r[i][j];
}
}
for (j = 1; j < m; j++) {
for (k = 0; k < n; k++) {
for (l = j; l < m; l++) {
rec[0][j][k][l] = rec[0][0][k][l] - rec[0][0][k][j - 1];
}
}
}
for (i = 1; i < n; i++) {
for (k = i; k < n; k++) {
for (l = 0; l < m; l++) {
rec[i][0][k][l] = rec[0][0][k][l] - rec[0][0][i - 1][l];
}
}
}
for (i = 1; i < n; i++) {
for (j = 1; j < m; j++) {
for (k = i; k < n; k++) {
for (l = j; l < m; l++) {
rec[i][j][k][l] = rec[0][0][k][l] - rec[0][0][i - 1][l] -
rec[0][0][k][j - 1] + rec[0][0][i - 1][j - 1];
}
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
for (k = i; k < n; k++) {
for (l = j; l < m; l++) {
if (rec[i][j][k][l] == 0)
rec[i][j][k][l] = 1;
else
rec[i][j][k][l] = 0;
}
}
}
}
for (a = 0; a < n; a++) {
for (b = 0; b < m; b++) {
con[a][b][a][b] = rec[a][b][a][b];
for (k = a + 1; k < n; k++) {
con[a][b][k][b] = con[a][b][k - 1][b];
for (i = a; i <= k; i++) {
con[a][b][k][b] += rec[i][b][k][b];
}
}
for (l = b + 1; l < m; l++) {
con[a][b][a][l] = con[a][b][a][l - 1];
for (j = b; j <= l; j++) {
con[a][b][a][l] += rec[a][j][a][l];
}
}
for (k = a + 1; k < n; k++) {
for (l = b + 1; l < m; l++) {
con[a][b][k][l] = con[a][b][k - 1][l] + con[a][b][k][l - 1] -
con[a][b][k - 1][l - 1];
for (i = a; i <= k; i++) {
for (j = b; j <= l; j++) {
con[a][b][k][l] += rec[i][j][k][l];
}
}
}
}
}
}
for (i = 0; i < q; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
printf("%d\n", con[a - 1][b - 1][c - 1][d - 1]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 50;
long long int dp1[MAX][MAX], dp2[MAX][MAX][MAX][MAX], dp3[MAX][MAX][MAX][MAX],
t[MAX][MAX], zero[MAX][MAX];
char c[MAX][MAX];
int main() {
long long int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c[i][j];
if (c[i][j] == '0')
t[i][j] = 0;
else
t[i][j] = 1;
int back = j;
while (back >= 1 and t[i][back] == 0) {
zero[i][j]++;
back--;
}
}
}
dp1[1][1] = t[1][1];
for (int i = 1; i <= m; i++) {
dp1[1][i] = dp1[1][i - 1] + t[1][i];
}
for (int i = 1; i <= n; i++) {
dp1[i][1] = dp1[i - 1][1] + t[i][1];
}
for (int i = 2; i <= n; i++) {
for (int j = 2; j <= m; j++) {
dp1[i][j] = dp1[i - 1][j] + dp1[i][j - 1] - dp1[i - 1][j - 1] + t[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = i; k <= n; k++) {
for (int p = j; p <= m; p++) {
dp2[i][j][k][p] = dp1[k][p] - dp1[i - 1][p] - dp1[k][j - 1];
if (i - 1 == 0 or j - 1 == 0) {
dp2[i][j][k][p] += 0;
} else {
dp2[i][j][k][p] += t[1][1];
}
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = i; k <= n; k++) {
for (int p = j; p <= m; p++) {
dp3[i][j][k][p] = dp3[i][j][k - 1][p] + dp3[i][j][k][p - 1] -
dp3[i][j][k - 1][p - 1];
long long int maxi = p - j + 1;
for (int cur = k; cur >= i; cur--) {
maxi = min(zero[cur][p], maxi);
dp3[i][j][k][p] = dp3[i][j][k][p] + maxi;
}
}
}
}
}
for (int i = 0; i < q; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << dp3[a][b][c][d] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
char grid[40][41];
bool isgood[50][50][50][50];
int sum[50][50][50][50];
int dp[50][50][50][50];
int main() {
int n, m, q, r1, r2, c1, c2, ans;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) scanf("%s", grid[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = i; k >= 0; k--)
for (int l = j; l >= 0; l--) {
sum[k][l][i][j] = sum[k][l + 1][i][j] + sum[k + 1][l][i][j] -
sum[k + 1][l + 1][i][j] + (grid[k][l] - '0');
if (!sum[k][l][i][j]) isgood[k][l][i][j] = 1;
}
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++)
for (int i = k; i >= 0; i--)
for (int j = l; j >= 0; j--)
dp[i][j][k][l] = dp[i + 1][j][k][l] + dp[i][j + 1][k][l] -
dp[i + 1][j + 1][k][l] + isgood[i][j][k][l];
for (int i = 0; i < q; i++) {
scanf("%d%d%d%d", &r1, &c1, &r2, &c2);
r1--;
c1--;
r2--;
c2--;
int ret = 0;
for (int i = r1; i <= r2; i++)
for (int j = c1; j <= c2; j++) ret += dp[r1][c1][i][j];
printf("%d\n", ret);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int *mem, *rl, n, m;
char mp[41][41];
int right_left(int r, int c, int rmin, int cmin) {
int index = (rmin - 1) * m * n * m + (cmin - 1) * n * m + (r - 1) * m + c - 1;
if (rl[index] != -1)
return rl[index];
else {
int len = r - rmin + 1, *tw = new int[len], ans = 0;
memset(tw, 0, len * 4);
for (int i = 0; i < len; i++) {
int j = 0;
while (mp[r - i][c - j] == '0' && j <= c - cmin) {
tw[i]++;
j++;
}
}
for (int i = 1; i <= len; i++) ans += *min_element(tw, tw + i);
delete[] tw;
return rl[index] = ans;
}
}
int f(int a, int b, int c, int d) {
int index = (a - 1) * m * n * m + (b - 1) * n * m + (c - 1) * m + d - 1;
if (mem[index] != -1)
return mem[index];
else {
int ans = 0;
for (int row = a; row <= c; row++)
for (int col = b; col <= d; col++) ans += right_left(row, col, a, b);
return mem[index] = ans;
}
}
int main() {
int cas, a, b, c, d;
for (int i = 0; i < 41; i++) mp[i][0] = mp[0][i] = '1';
while (cin >> n >> m >> cas) {
mem = new int[n * m * n * m];
rl = new int[n * m * n * m];
memset(mem, -1, n * m * n * m * 4);
memset(rl, -1, n * m * n * m * 4);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> mp[i][j];
while (cas--) {
cin >> a >> b >> c >> d;
(cout << f(a, b, c, d) << endl);
}
}
return 0;
}
|
#include <bits/stdc++.h>
char data[41][41];
int t[41][41][41][41];
int chk[41][41][41][41];
int main() {
int a, b, c, d, i, j, k, l, p, q, sum = 0;
scanf("%d %d %d", &a, &b, &q);
for (i = 0; i < a; ++i) {
scanf("%s", data[i]);
for (j = 0; j < b; ++j) {
if (data[i][j] == '0') {
chk[i][j][i][j] = 1;
for (k = i; k >= 0; --k) {
for (l = j; l >= 0; --l) {
if (l == j && k == i)
t[k][l][i][j] = chk[k][l][i][j];
else if (l == j) {
chk[k][l][i][j] = ('1' - data[k][l]) && (chk[k + 1][l][i][j]);
t[k][l][i][j] = t[k + 1][l][i][j] + chk[k][l][i][j];
} else if (k == i) {
chk[k][l][i][j] = ('1' - data[k][l]) && (chk[k][l + 1][i][j]);
t[k][l][i][j] = t[k][l + 1][i][j] + chk[k][l][i][j];
} else {
chk[k][l][i][j] = ('1' - data[k][l]) && (chk[k + 1][l][i][j]) &&
(chk[k][l + 1][i][j]);
t[k][l][i][j] = t[k + 1][l][i][j] + t[k][l + 1][i][j] -
t[k + 1][l + 1][i][j] + chk[k][l][i][j];
}
}
}
}
}
}
for (p = 0; p < q; ++p) {
scanf("%d %d %d %d", &a, &b, &c, &d);
for (i = a - 1; i <= c - 1; ++i) {
for (j = b - 1; j <= d - 1; ++j) {
sum += t[a - 1][b - 1][i][j];
}
}
printf("%d\n", sum);
sum = 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a, b, c, d, dp[50][50][50][50], A[50][50];
string s[50];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i <= n - 1; i++) cin >> s[i];
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= m - 1; j++)
if (s[i][j] == '0') A[i + 1][j + 1] = A[i + 1][j] + 1;
for (int w = 1; w <= m; w++)
for (int h = 1; h <= n; h++)
for (int i = 1; i <= n - h + 1; i++)
for (int j = 1; j <= m - w + 1; j++) {
dp[i][i + h - 1][j][j + w - 1] = dp[i][i + h - 1][j][j + w - 2] +
dp[i][i + h - 2][j][j + w - 1] -
dp[i][i + h - 2][j][j + w - 2];
for (int k = i + h - 1, C = w; k >= i; k--) {
if (A[k][j + w - 1] < C) C = A[k][j + w - 1];
dp[i][i + h - 1][j][j + w - 1] += C;
}
}
for (int i = 1; i <= q; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", dp[a][c][b][d]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int N = 50 + 10, M = 1e6 + 10, inf = 1e9 + 10;
const long long INF = 5e17 + 10, mod = 1e9 + 7;
int a[N][N], cnt[N][N][N][N];
int s[N][N], sum[N][N][N][N];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%1d", &a[i][j]);
s[i][j] = a[i][j] + s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
for (int k = i; k <= n; k++) {
for (int l = j; l <= m; l++) {
int x = s[k][l] - s[i - 1][l] - s[k][j - 1] + s[i - 1][j - 1];
cnt[i][j][k][l] = cnt[i][j][k][l - 1] + cnt[i][j][k - 1][l] -
cnt[i][j][k - 1][l - 1] + !x;
}
}
}
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
for (int k = i; k <= n; k++) {
for (int l = j; l <= m; l++) {
sum[i][j][k][l] = sum[i + 1][j][k][l] + sum[i][j + 1][k][l] -
sum[i + 1][j + 1][k][l] + cnt[i][j][k][l];
}
}
}
}
while (q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", sum[a][b][c][d]);
}
return 0;
}
|
#include <bits/stdc++.h>
int map[50][50];
int rui[51][51];
int dat[50][50][50][50];
int ans[51][51][51][51];
int main() {
memset(dat, 0, sizeof(dat));
int mx, my, query;
scanf("%d%d%d", &mx, &my, &query);
for (int i = 0; i < mx; i++) {
for (int j = 0; j < my; j++) {
char zan;
scanf(" %c", &zan);
map[i][j] = zan - '0';
}
}
for (int i = 0; i < mx; i++) {
for (int j = 0; j < my; j++) {
rui[i + 1][j + 1] = rui[i + 1][j] + rui[i][j + 1] - rui[i][j] + map[i][j];
}
}
for (int i = 0; i < mx; i++) {
for (int j = 0; j < my; j++) {
for (int k = i; k < mx; k++) {
for (int l = j; l < my; l++) {
if (rui[k + 1][l + 1] - rui[i][l + 1] - rui[k + 1][j] + rui[i][j] ==
0) {
dat[i][j][k][l] = 1;
}
}
}
}
}
for (int i = 0; i < mx; i++) {
for (int j = 0; j < my; j++) {
for (int k = 0; k < mx; k++) {
for (int l = 0; l < my; l++) {
ans[i + 1][j + 1][k + 1][l + 1] =
ans[i][j + 1][k + 1][l + 1] + ans[i + 1][j][k + 1][l + 1] +
ans[i + 1][j + 1][k][l + 1] + ans[i + 1][j + 1][k + 1][l] -
ans[i][j][k + 1][l + 1] - ans[i][j + 1][k][l + 1] -
ans[i][j + 1][k + 1][l] - ans[i + 1][j][k][l + 1] -
ans[i + 1][j][k + 1][l] - ans[i + 1][j + 1][k][l] +
ans[i + 1][j][k][l] + ans[i][j + 1][k][l] + ans[i][j][k + 1][l] +
ans[i][j][k][l + 1] - ans[i][j][k][l] + dat[i][j][k][l];
}
}
}
}
for (int p = 0; p < query; p++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a--;
b--;
c--;
d--;
printf("%d\n",
ans[c + 1][d + 1][c + 1][d + 1] - ans[a][d + 1][c + 1][d + 1] -
ans[c + 1][b][c + 1][d + 1] - ans[c + 1][d + 1][a][d + 1] -
ans[c + 1][d + 1][c + 1][b] + ans[a][b][c + 1][d + 1] +
ans[a][d + 1][a][d + 1] + ans[a][d + 1][c + 1][b] +
ans[c + 1][b][a][d + 1] + ans[c + 1][b][c + 1][b] +
ans[c + 1][d + 1][a][b] - ans[c + 1][b][a][b] -
ans[a][d + 1][a][b] - ans[a][b][c + 1][b] - ans[a][b][a][d + 1] +
ans[a][b][a][b]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 7;
const int MXN = 50;
int n, m, q;
int dp[MXN][MXN][MXN][MXN];
int lt[MXN][MXN];
char a[MXN][MXN];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
lt[i][j] = lt[i][j - 1];
if (a[i][j] == '1') lt[i][j] = j;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = i; k <= n; k++) {
for (int l = j; l <= m; l++) {
dp[i][j][k][l] =
dp[i][j][k - 1][l] + dp[i][j][k][l - 1] - dp[i][j][k - 1][l - 1];
int cur = j - 1;
for (int q = k; q >= i; q--) {
if (a[q][l] == '1') break;
cur = max(cur, lt[q][l]);
dp[i][j][k][l] += l - cur;
}
}
}
}
}
while (q--) {
int x, y, z, q;
scanf("%d%d%d%d", &x, &y, &z, &q);
printf("%d\n", dp[x][y][z][q]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a[77][77], sm[77][77], sum[77][77][77][77], x, y, xx, yy;
char str[77];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", str);
for (int j = 1; j <= m; j++) {
a[i][j] = str[j - 1] - '0';
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sm[i][j] = sm[i - 1][j] + sm[i][j - 1] - sm[i - 1][j - 1] + a[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
for (int k = 1; k <= m; k++) {
for (int h = k; h <= m; h++) {
if (!(sm[j][h] - sm[i - 1][h] - sm[j][k - 1] + sm[i - 1][k - 1])) {
sum[i][j][k][h]++;
}
}
}
}
}
for (int i = n; i >= 1; i--) {
for (int j = i; j <= n; j++) {
for (int k = m; k >= 1; k--) {
for (int h = k; h <= m; h++) {
sum[i][j][k][h] =
sum[i][j][k][h] + sum[i + 1][j][k][h] + sum[i][j - 1][k][h] +
sum[i][j][k + 1][h] + sum[i][j][k][h - 1] -
sum[i + 1][j - 1][k][h] - sum[i + 1][j][k + 1][h] -
sum[i + 1][j][k][h - 1] - sum[i][j - 1][k + 1][h] -
sum[i][j - 1][k][h - 1] - sum[i][j][k + 1][h - 1] +
sum[i + 1][j - 1][k + 1][h] + sum[i + 1][j - 1][k][h - 1] +
sum[i + 1][j][k + 1][h - 1] + sum[i][j - 1][k + 1][h - 1] -
sum[i + 1][j - 1][k + 1][h - 1];
}
}
}
}
while (q--) {
scanf("%d%d%d%d", &x, &y, &xx, &yy);
printf("%d\n", sum[x][xx][y][yy]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 40 + 10;
const int Mod = 1e9 + 7;
const long long int Inf = 1LL << 62;
int cum[Max][Max];
int cnt[Max][Max][Max][Max];
char ch[Max];
int main() {
int n, m, q, a, b, c, d;
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
cin >> ch;
for (int j = 1; j <= m; j++) {
cum[i][j] = cum[i][j - 1] + (ch[j - 1] == '1');
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int mp[Max] = {0};
for (int k = i; k <= n; k++) {
for (int l = j; l <= m; l++) {
int ans = 0;
for (int m = j; m <= l; m++) {
cnt[i][j][k][l] += mp[m];
}
for (int m = i; m <= k; m++) {
ans += cum[m][l] - cum[m][j - 1];
}
if (ans == 0) {
cnt[i][j][k][l] += 1;
mp[l] += 1;
}
}
}
}
}
while (q--) {
int ans = 0;
scanf("%d %d %d %d", &a, &b, &c, &d);
for (int i = a; i <= c; i++) {
for (int j = b; j <= d; j++) {
ans += cnt[i][j][c][d];
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
long long dp[42][42][42][42], accc[42][42][42][42];
int acc[42][42], arr[42][42];
int beut[42][42][42][42];
int sx[] = {-1, 0, -1};
int sy[] = {0, -1, -1};
int solve(int a, int b, int c, int d) {
if (dp[a][b][c][d] != -1) return dp[a][b][c][d];
int ret = beut[a][b][c][d];
if (c > a) ret += solve(a, b, c - 1, d);
if (d > b) ret += solve(a, b, c, d - 1);
if (c > a && d > b) ret -= solve(a, b, c - 1, d - 1);
return dp[a][b][c][d] = ret;
}
int main() {
cin >> n >> m >> q;
n++;
m++;
string s;
for (int i = 1; i < n; i++) {
cin >> s;
for (int j = 1; j < m; j++) {
arr[i][j] = s[j - 1] - '0';
}
}
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++) {
acc[i][j] = acc[i - 1][j] + acc[i][j - 1] - acc[i - 1][j - 1] + arr[i][j];
}
for (int i1 = 1; i1 < n; i1++)
for (int i2 = i1; i2 < n; i2++)
for (int j1 = 1; j1 < m; j1++)
for (int j2 = j1; j2 < m; j2++) {
int sum = acc[i2][j2] + acc[i1 - 1][j1 - 1] - acc[i2][j1 - 1] -
acc[i1 - 1][j2];
if (sum == 0) {
beut[i1][j1][i2][j2] = 1;
}
}
memset(dp, -1, sizeof dp);
while (q--) {
int ai, bi, ci, di;
scanf("%d %d %d %d", &ai, &bi, &ci, &di);
int res = 0;
for (int i = ai; i <= ci; i++)
for (int j = bi; j <= di; j++) {
res += solve(i, j, ci, di);
}
printf("%d\n", res);
}
}
|
#include <bits/stdc++.h>
long long gcd(long long A, long long B) {
return A > B ? gcd(B, A) : A ? gcd(B % A, A) : B;
}
long long lcm(long long A, long long B) { return A / gcd(A, B) * B; }
long long pow(long long A, long long B, long long P) {
if (!B) return 1 % P;
if (B == 1) return A % P;
long long h = pow(A, B / 2, P);
h *= h;
h %= P;
if (B % 2) h *= A;
return h % P;
}
using namespace std;
int n, m, q, i, j, I, J;
int a[41][41];
int sum[41][41];
int res[41][41][41][41];
int all[41][41][41][41];
char ch;
int get(int i, int j, int I, int J) {
return sum[I][J] - sum[i - 1][J] - sum[I][j - 1] + sum[i - 1][j - 1];
}
bool f(int k) {
if (k == 0)
return true;
else
return false;
}
int main() {
cin >> n >> m >> q;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
cin >> ch;
a[i][j] = ch - '0';
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
}
for (i = n; i >= 1; i--)
for (j = m; j >= 1; j--)
if (!a[i][j]) {
all[i][j][i][j] = 1;
for (I = i - 1; I >= 1; I--)
all[I][j][i][j] = all[I + 1][j][i][j] + f(get(I, j, i, j));
for (J = j - 1; J >= 1; J--)
all[i][J][i][j] = all[i][J + 1][i][j] + f(get(i, J, i, j));
for (I = i - 1; I >= 1; I--)
for (J = j - 1; J >= 1; J--)
all[I][J][i][j] = all[I][J + 1][i][j] + all[I + 1][J][i][j] -
all[I + 1][J + 1][i][j] + f(get(I, J, i, j));
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (!a[i][j]) res[i][j][i][j] = 1;
for (I = i + 1; I <= n; I++)
res[i][j][I][j] = res[i][j][I - 1][j] + all[i][j][I][j];
for (J = j + 1; J <= m; J++)
res[i][j][i][J] = res[i][j][i][J - 1] + all[i][j][i][J];
for (I = i + 1; I <= n; I++)
for (J = j + 1; J <= m; J++)
res[i][j][I][J] = res[i][j][I][J - 1] + res[i][j][I - 1][J] -
res[i][j][I - 1][J - 1] + all[i][j][I][J];
}
while (q--) {
cin >> i >> j >> I >> J;
cout << res[i][j][I][J] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 47;
int sum[size][size];
int good[size][size][size][size];
int dp[size][size][size][size];
int source[size][size];
int main() {
int n, m, qs;
cin >> n >> m >> qs;
for (int i = 1; i < n + 1; ++i) {
for (int j = 1; j < m + 1; ++j) {
char c;
cin >> c;
source[i][j] = (c - '0');
}
}
for (int i = 1; i < n + 1; ++i) {
for (int j = 1; j < m + 1; ++j) {
sum[i][j] =
sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + source[i][j];
}
}
for (int i = 1; i < n + 1; ++i) {
for (int j = 1; j < m + 1; ++j) {
for (int q = i; q < n + 1; ++q) {
for (int w = j; w < m + 1; ++w) {
int curr =
sum[q][w] - sum[q][j - 1] - sum[i - 1][w] + sum[i - 1][j - 1];
good[i][j][q][w] = (curr == 0);
}
}
}
}
for (int i = 1; i < n + 1; ++i) {
for (int j = 1; j < m + 1; ++j) {
for (int q = i; q < n + 1; ++q) {
for (int w = j; w < m + 1; ++w) {
dp[i][j][q][w] = dp[i][j][q - 1][w] + dp[i][j][q][w - 1] -
dp[i][j][q - 1][w - 1] + good[i][j][q][w];
}
}
}
}
for (int q = n; q >= 1; --q) {
for (int w = m; w >= 1; --w) {
for (int i = q; i >= 1; --i) {
for (int j = w; j >= 1; --j) {
dp[i][j][q][w] = dp[i][j][q][w] + dp[i + 1][j][q][w] +
dp[i][j + 1][q][w] - dp[i + 1][j + 1][q][w];
}
}
}
}
for (int i = 0; i < qs; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << dp[a][b][c][d] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[45][45][45][45], str[45][45], row[45][45];
int main() {
int N, M, Q, a, b, c, d, e, r;
scanf("%d%d%d", &N, &M, &Q);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
scanf("%1d", &str[i][j]);
row[i][j] = row[i][j - 1];
if (str[i][j])
row[i][j] = 0;
else
row[i][j]++;
}
for (a = 1; a <= N; a++) {
for (b = 1; b <= M; b++) {
for (c = a; c <= N; c++) {
for (d = b; d <= M; d++) {
dp[a][b][c][d] =
dp[a][b][c - 1][d] + dp[a][b][c][d - 1] - dp[a][b][c - 1][d - 1];
r = d - b + 1;
for (e = c; e >= a && r; e--) {
r = (r < row[e][d]) ? r : row[e][d];
dp[a][b][c][d] += r;
}
}
}
}
}
while (Q--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", dp[a][b][c][d]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int grid[50][50], ile[50][50][50][50], lewo[50][50];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == '0')
grid[i][j + 1] = 0;
else
grid[i][j + 1] = 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (grid[i][j] == 1)
lewo[i][j] = 0;
else
lewo[i][j] = lewo[i][j - 1] + 1;
}
}
for (int a = 1; a <= n; a++) {
for (int b = 1; b <= m; b++) {
for (int i = a; i <= n; i++) {
for (int j = b; j <= m; j++) {
if (grid[i][j] == 1) {
ile[i][j][a][b] = ile[i - 1][j][a][b] + ile[i][j - 1][a][b] -
ile[i - 1][j - 1][a][b];
} else {
ile[i][j][a][b] = ile[i - 1][j][a][b] + ile[i][j - 1][a][b] -
ile[i - 1][j - 1][a][b];
int blokada = lewo[i][j];
for (int k = i; k >= a; k--) {
if (grid[k][j] == 1) break;
ile[i][j][a][b] += min(blokada, min(lewo[k][j], j - b + 1));
blokada = min(blokada, lewo[k][j]);
}
}
}
}
}
}
for (int i = 0; i < q; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int wynik = ile[c][d][a][b];
printf("%d\n", wynik);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
bool dp[40][40][40][40];
bool inp[40][40];
int dp1[40][40][40][40];
int ans[40][40][40][40];
int main() {
int n, m, Q;
string str;
cin >> n >> m >> Q;
for (int i = 0; i < (n); ++i) {
cin >> str;
for (int j = 0; j < (m); ++j) inp[i][j] = 1 - (str[j] - '0');
}
for (int x1 = 0; x1 < n; ++x1) {
for (int y1 = 0; y1 < m; ++y1) {
dp[x1][y1][x1][y1] = inp[x1][y1];
for (int x2 = x1 + 1; x2 < n; ++x2) {
dp[x1][y1][x2][y1] = (dp[x1][y1][x2 - 1][y1] & inp[x2][y1]);
}
for (int y2 = y1 + 1; y2 < m; ++y2) {
dp[x1][y1][x1][y2] = (dp[x1][y1][x1][y2 - 1] & inp[x1][y2]);
}
for (int x2 = x1 + 1; x2 < n; ++x2)
for (int y2 = y1 + 1; y2 < m; ++y2) {
dp[x1][y1][x2][y2] =
(dp[x1][y1][x2][y2 - 1] & dp[x1][y1][x2 - 1][y2] & inp[x2][y2]);
}
}
}
for (int x1 = 0; x1 < n; ++x1) {
for (int y1 = 0; y1 < m; ++y1) {
dp1[x1][y1][x1][y1] = inp[x1][y1];
for (int x2 = x1 - 1; x2 >= 0; --x2) {
dp1[x2][y1][x1][y1] = (dp1[x2 + 1][y1][x1][y1] + dp[x2][y1][x1][y1]);
}
for (int y2 = y1 - 1; y2 >= 0; --y2) {
dp1[x1][y2][x1][y1] = (dp1[x1][y2 + 1][x1][y1] + dp[x1][y2][x1][y1]);
}
for (int x2 = x1 - 1; x2 >= 0; --x2)
for (int y2 = y1 - 1; y2 >= 0; --y2) {
dp1[x2][y2][x1][y1] =
(dp1[x2][y2 + 1][x1][y1] + dp1[x2 + 1][y2][x1][y1] -
dp1[x2 + 1][y2 + 1][x1][y1] + dp[x2][y2][x1][y1]);
}
}
}
for (int x1 = 0; x1 < n; ++x1) {
for (int y1 = 0; y1 < m; ++y1) {
ans[x1][y1][x1][y1] = dp[x1][y1][x1][y1];
for (int x2 = x1 + 1; x2 < n; ++x2) {
ans[x1][y1][x2][y1] = ans[x1][y1][x2 - 1][y1] + dp1[x1][y1][x2][y1];
}
for (int y2 = y1 + 1; y2 < m; ++y2) {
ans[x1][y1][x1][y2] = ans[x1][y1][x1][y2 - 1] + dp1[x1][y1][x1][y2];
}
for (int x2 = x1 + 1; x2 < n; ++x2) {
for (int y2 = y1 + 1; y2 < m; ++y2) {
ans[x1][y1][x2][y2] =
ans[x1][y1][x2 - 1][y2] + ans[x1][y1][x2][y2 - 1] -
ans[x1][y1][x2 - 1][y2 - 1] + dp1[x1][y1][x2][y2];
}
}
}
}
while (Q--) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
--x1, --y1, --x2, --y2;
cout << ans[x1][y1][x2][y2] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
char a[int(42)][int(42)];
int f[int(42)][int(42)][int(42)][int(42)];
bool t[int(42)][int(42)][int(42)][int(42)];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = (1), _b = (n); i <= _b; i++) scanf("%s", a[i] + 1);
memset(t, true, sizeof(t));
for (int x1 = (1), _b = (n); x1 <= _b; x1++)
for (int y1 = (1), _b = (m); y1 <= _b; y1++) {
for (int x2 = (x1), _b = (n); x2 <= _b; x2++)
for (int y2 = (y1), _b = (m); y2 <= _b; y2++) {
if (x1 == x2 && y1 == y2) {
if (a[x2][y2] == '1') {
t[x1][y1][x2][y2] = false;
}
} else {
if (a[x2][y2] == '1' || t[x1][y1][x2 - 1][y2] == false ||
t[x1][y1][x2][y2 - 1] == false)
t[x1][y1][x2][y2] = false;
}
}
}
for (int x2 = (1), _b = (n); x2 <= _b; x2++)
for (int y2 = (1), _b = (m); y2 <= _b; y2++) {
for (int x1 = (x2), _a = (1); x1 >= _a; x1--)
for (int y1 = (y2), _a = (1); y1 >= _a; y1--) {
f[x1][y1][x2][y2] += f[x1 + 1][y1][x2][y2] + f[x1][y1 + 1][x2][y2] -
f[x1 + 1][y1 + 1][x2][y2];
if (t[x1][y1][x2][y2]) f[x1][y1][x2][y2]++;
}
}
for (int x1 = (1), _b = (n); x1 <= _b; x1++)
for (int y1 = (1), _b = (m); y1 <= _b; y1++) {
for (int x2 = (x1), _b = (n); x2 <= _b; x2++)
for (int y2 = (y1), _b = (m); y2 <= _b; y2++) {
f[x1][y1][x2][y2] += f[x1][y1][x2 - 1][y2] + f[x1][y1][x2][y2 - 1] -
f[x1][y1][x2 - 1][y2 - 1];
}
}
for (int i = (1), _b = (q); i <= _b; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
printf("%d\n", f[x1][y1][x2][y2]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[45][45][45][45] = {0};
int sumar[45][45] = {0};
int ar[45][45] = {0};
int check(int i, int j, int p, int q) {
int s1 = sumar[p][q];
int s2 = sumar[i - 1][q];
int s3 = sumar[p][j - 1];
int s4 = sumar[i - 1][j - 1];
return ((s1 - s2 - s3 + s4) == 0);
}
int main() {
int m, q, n;
char ch;
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < n; i++) {
getchar();
for (int j = 0; j < m; j++) {
ch = getchar();
ar[i][j] = ch - '0';
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sumar[i][j] = sumar[i][j - 1] + sumar[i - 1][j] - sumar[i - 1][j - 1] +
ar[i - 1][j - 1];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int p = i; p <= n; p++) {
for (int q = j; q <= m; q++) {
dp[i][j][p][q] = dp[i][j][p - 1][q] + dp[i][j][p][q - 1] -
dp[i][j][p - 1][q - 1] + check(i, j, p, q);
}
}
}
}
for (int p = n; p >= 1; p--) {
for (int q = m; q >= 1; q--) {
for (int i = p; i >= 1; i--) {
for (int j = q; j >= 1; j--) {
dp[i][j][p][q] +=
dp[i + 1][j][p][q] + dp[i][j + 1][p][q] - dp[i + 1][j + 1][p][q];
}
}
}
}
int a, b, c, d;
for (int i = 0; i < q; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
cout << dp[a][b][c][d] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
struct T {
int up, left, c;
} dp[45][45][45][45];
int n, m, q, cnt[45][45][45][45];
char a[45][45];
void solve(int lx, int ly) {
for (int i = 0; i < 45; ++i)
for (int j = 0; j < 45; ++j)
dp[lx][ly][i][j].up = dp[lx][ly][i][j].left = dp[lx][ly][i][j].c = 0;
if (a[lx][ly] == '0') dp[lx][ly][lx][ly].up = dp[lx][ly][lx][ly].left = 1;
for (int i = lx + 1; i <= n; ++i)
if (a[i][ly] == '0') {
dp[lx][ly][i][ly].up = dp[lx][ly][i - 1][ly].up + 1;
dp[lx][ly][i][ly].left = 1;
}
for (int i = ly + 1; i <= m; ++i)
if (a[lx][i] == '0') {
dp[lx][ly][lx][i].up = 1;
dp[lx][ly][lx][i].left = dp[lx][ly][lx][i - 1].left + 1;
}
for (int i = lx + 1; i <= n; ++i)
for (int j = ly + 1; j <= m; ++j)
if (a[i][j] == '0') {
dp[lx][ly][i][j].up = dp[lx][ly][i - 1][j].up + 1;
dp[lx][ly][i][j].left = dp[lx][ly][i][j - 1].left + 1;
}
for (int j = ly; j <= m; ++j)
for (int i = lx; i <= n; ++i)
if (a[i][j] == '0') {
if (i == lx && j == ly)
dp[lx][ly][i][j].c = 1;
else if (i == lx)
dp[lx][ly][i][j].c = dp[lx][ly][i][j - 1].c + 1;
else if (j == ly)
dp[lx][ly][i][j].c = dp[lx][ly][i - 1][j].c + 1;
else {
if (dp[lx][ly][i][j].left >= dp[lx][ly][i - 1][j].left)
dp[lx][ly][i][j].c = dp[lx][ly][i - 1][j].c + dp[lx][ly][i][j].left;
else {
int h = i - 1;
while (h >= lx && dp[lx][ly][h][j].left > dp[lx][ly][i][j].left)
--h;
if (h == lx - 1)
dp[lx][ly][i][j].c = (i - h) * dp[lx][ly][i][j].left;
else
dp[lx][ly][i][j].c =
dp[lx][ly][h][j].c + (i - h) * dp[lx][ly][i][j].left;
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf(" %c", &a[i][j]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) solve(i, j);
for (int id = 1; id <= q; ++id) {
int b, c, d, e;
scanf("%d%d%d%d", &b, &c, &d, &e);
int ans = 0;
for (int i = b; i <= d; ++i)
for (int j = c; j <= e; ++j) ans += dp[b][c][i][j].c;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
string B[41];
int sum[41][41], cnt[41][41][41][41], a[41][41];
int main(int argv, char *argc[]) {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> B[i];
for (int j = 1; j <= m; j++) {
a[i][j] = (B[i][j - 1] == '1');
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (i == 0 || j == 0) {
sum[i][j] = 0;
} else {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + a[i][j];
}
}
}
for (int xa = 1; xa <= n; xa++) {
for (int ya = 1; ya <= m; ya++) {
for (int xb = xa; xb <= n; xb++) {
for (int yb = ya; yb <= m; yb++) {
int nsum = sum[xb][yb] - sum[xa - 1][yb] - sum[xb][ya - 1] +
sum[xa - 1][ya - 1];
cnt[xa][ya][xb][yb] = (nsum == 0);
}
}
}
}
for (int xa = n; xa > 1; xa--) {
for (int ya = 1; ya <= m; ya++) {
for (int xb = xa; xb <= n; xb++) {
for (int yb = ya; yb <= m; yb++) {
cnt[xa - 1][ya][xb][yb] += cnt[xa][ya][xb][yb];
}
}
}
}
for (int xa = 1; xa <= n; xa++) {
for (int ya = m; ya > 1; ya--) {
for (int xb = xa; xb <= n; xb++) {
for (int yb = ya; yb <= m; yb++) {
cnt[xa][ya - 1][xb][yb] += cnt[xa][ya][xb][yb];
}
}
}
}
for (int xa = 1; xa <= n; xa++) {
for (int ya = 1; ya <= m; ya++) {
for (int xb = xa; xb <= n; xb++) {
for (int yb = ya; yb <= m; yb++) {
cnt[xa][ya][xb + 1][yb] += cnt[xa][ya][xb][yb];
}
}
}
}
for (int xa = 1; xa <= n; xa++) {
for (int ya = 1; ya <= m; ya++) {
for (int xb = xa; xb <= n; xb++) {
for (int yb = ya; yb <= m; yb++) {
cnt[xa][ya][xb][yb + 1] += cnt[xa][ya][xb][yb];
}
}
}
}
for (int i = 0; i < q; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << cnt[a][b][c][d] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
int sum[43][43][43][43];
int n, m, q;
int ans;
int col[43][43];
char s[43];
int main() {
int i, j, cnt;
int u, d, l, r;
while (scanf("%d%d%d", &n, &m, &q) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%s", &s[1]);
for (j = 1; j <= m; j++) {
col[i][j] = col[i - 1][j];
if (s[j] == '1') col[i][j]++;
}
}
for (u = 1; u <= n; u++) {
for (d = u; d <= n; d++) {
for (l = 1; l <= m; l++) {
cnt = 0;
for (r = l; r <= m; r++) {
if (col[d][r] != col[u - 1][r])
cnt = 0;
else
++cnt;
sum[u][d][l][r] = sum[u][d][l][r - 1] + cnt;
}
}
}
}
while (q--) {
scanf("%d%d%d%d", &u, &l, &d, &r);
ans = 0;
for (i = u; i <= d; i++) {
for (j = i; j <= d; j++) {
ans += sum[i][j][l][r];
}
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
int n, m, q, dp[N][N], DP[N][N][N][N], node[N][N], grid[N][N];
bool valid(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
void createdp() {
for (int i = m - 1; i >= 0; i--)
for (int j = n - 1; j >= 0; j--) {
int Right = 0, down = 0, digonal = 0;
if (valid(j, i + 1)) Right = dp[j][i + 1];
if (valid(j + 1, i)) down = dp[j + 1][i];
if (valid(j + 1, i + 1)) digonal = dp[j + 1][i + 1];
dp[j][i] = Right + down - digonal;
if (grid[j][i]) continue;
int mn = n;
for (int col = i; col < m; col++)
for (int row = j; row < mn; row++)
if (grid[row][col]) {
mn = min(mn, row);
break;
} else
node[j][i]++;
dp[j][i] += node[j][i];
}
}
void creatanotherdp() {
for (int i = m - 1; i >= 0; i--)
for (int j = n - 1; j >= 0; j--) {
int mn = n;
for (int col = i; col < m; col++)
for (int row = j; row < mn; row++)
if (grid[row][col]) {
mn = min(mn, row);
break;
} else
DP[j][i][row][col]++;
for (int col = 0; col < m; col++)
for (int row = n - 2; row >= 0; row--)
DP[j][i][row][col] += DP[j][i][row + 1][col];
for (int row = 0; row < n; row++)
for (int col = m - 2; col >= 0; col--)
DP[j][i][row][col] += DP[j][i][row][col + 1];
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
string s;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < m; j++) grid[i][j] = (s[j] - '0');
}
createdp();
creatanotherdp();
while (q--) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int ans = dp[x1 - 1][y1 - 1];
ans -= dp[x1 - 1][y2];
ans -= dp[x2][y1 - 1];
ans += dp[x2][y2];
int nodes = 0;
for (int i = x1 - 1; i < x2; i++)
for (int j = y1 - 1; j < y2; j++)
nodes += DP[i][j][x1 - 1][y2] + DP[i][j][x2][y1 - 1] - DP[i][j][x2][y2];
ans -= nodes;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[42][42][42][42], sat[42][42];
int n, m, q;
int query(int x1, int y1, int x2, int y2) {
x1--, y1--;
return sat[x2][y2] + sat[x1][y1] - sat[x1][y2] - sat[x2][y1];
}
int rec(int a, int b, int c, int d) {
if (a > c || b > d) return 0;
int &ret = dp[a][b][c][d];
if (ret != -1) return ret;
ret = (query(a, b, c, d) == (c - a + 1) * (d - b + 1));
ret += rec(a, b, c - 1, d) + rec(a, b, c, d - 1) - rec(a, b, c - 1, d - 1);
ret += rec(a + 1, b, c, d) + rec(a, b + 1, c, d) - rec(a + 1, b + 1, c, d);
ret -= rec(a + 1, b, c - 1, d) + rec(a + 1, b, c, d - 1) -
rec(a + 1, b, c - 1, d - 1);
ret -= rec(a, b + 1, c - 1, d) + rec(a, b + 1, c, d - 1) -
rec(a, b + 1, c - 1, d - 1);
ret += rec(a + 1, b + 1, c - 1, d) + rec(a + 1, b + 1, c, d - 1) -
rec(a + 1, b + 1, c - 1, d - 1);
return ret;
}
void setup() {
cin >> n >> m >> q;
int here;
for (int a = 1; a < n + 1; a++) {
for (int b = 1; b < m + 1; b++) {
scanf("%1d", &here);
sat[a][b] = 1 - here + sat[a - 1][b] + sat[a][b - 1] - sat[a - 1][b - 1];
}
}
}
int main() {
setup();
int a, b, c, d;
memset(dp, -1, sizeof dp);
while (q--) {
cin >> a >> b >> c >> d;
cout << rec(a, b, c, d) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve();
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
solve();
}
const int N = 41;
int g[N][N], rec[N][N][N][N];
int n, m, Q;
void read() {
cin >> n >> m >> Q;
memset(g, 0, sizeof(g));
memset(rec, 0, sizeof(rec));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
char ch;
cin >> ch;
g[i + 1][j + 1] = ch - '0';
}
}
}
int cnt(int x1, int y1, int x2, int y2) {
return g[x2][y2] - g[x2][y1 - 1] - g[x1 - 1][y2] + g[x1 - 1][y1 - 1];
}
void solve() {
read();
for (int i = 1; i < n + 1; ++i) {
for (int j = 0; j < m + 1; ++j) {
g[i][j] += g[i - 1][j];
}
}
for (int i = 1; i < m + 1; ++i) {
for (int j = 0; j < n + 1; ++j) {
g[j][i] += g[j][i - 1];
}
}
for (int i = 1; i < n + 1; ++i) {
for (int j = 1; j < m + 1; ++j) {
for (int p = i; p < n + 1; ++p) {
for (int q = j; q < m + 1; ++q) {
if (cnt(i, j, p, q) == 0) {
rec[i][j][p][q] = 1;
}
}
}
}
}
for (int i = 0; i < n + 1; ++i) {
for (int j = 0; j < m + 1; ++j) {
for (int p = 1; p < n + 1; ++p) {
for (int q = 1; q < m + 1; ++q) {
rec[i][j][p][q] += rec[i][j][p - 1][q] + rec[i][j][p][q - 1] -
rec[i][j][p - 1][q - 1];
}
}
}
}
while (Q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
long long ans = 0;
for (int i = a; i < c + 1; ++i) {
for (int j = b; j < d + 1; ++j) {
ans += (rec[i][j][c][d] - rec[i][j][i - 1][d] - rec[i][j][c][j - 1] +
rec[i][j][i - 1][j - 1]);
}
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 2e9;
const long long INF64 = 1e18;
const long double EPS = 1e-12;
const long double PI = 3.1415926535897932384626433832795028841;
const long long MD = 925262732;
const long long T = 634521;
const int N = 200010;
const int M = 301;
int n, m, q;
long long d[41][41][41][41];
string s[41];
int main() {
cin >> n >> m >> q;
for (int i = 0; i < int(n); i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int y1 = 0; y1 < m; y1++)
for (int y2 = y1; y2 < m; y2++) {
if (s[i][y2] == '1') break;
for (int k = 1; k <= i + 1; k++)
if (k == 1)
d[i][y1][y2][k] = 1;
else if (i > 0)
d[i][y1][y2][k] = d[i - 1][y1][y2][k - 1];
}
for (int i = 0; i < n; i++)
for (int y1 = 0; y1 < m; y1++)
for (int y2 = y1; y2 < m; y2++) {
if (s[i][y2] == '1') break;
for (int k = 1; k <= i + 1; k++)
if (d[i][y1][y2][k])
d[i][y1][y2][k] = k;
else
d[i][y1][y2][k] = d[i][y1][y2][k - 1];
}
for (int i = 0; i < n; i++)
for (int y1 = m - 1; y1 >= 0; y1--)
for (int y2 = y1; y2 < m; y2++)
for (int k = 1; k <= i + 1; k++)
if (y2 > 0) d[i][y1][y2][k] += d[i][y1][y2 - 1][k];
for (int i = 0; i < n; i++)
for (int y1 = m - 1; y1 >= 0; y1--)
for (int y2 = y1; y2 < m; y2++)
for (int k = 1; k <= i + 1; k++) d[i][y1][y2][k] += d[i][y1 + 1][y2][k];
for (int i = 0; i < n; i++)
for (int y1 = 0; y1 < m; y1++)
for (int y2 = y1; y2 < m; y2++)
for (int k = 1; k <= i + 1; k++)
if (i > 0) d[i][y1][y2][k] += d[i - 1][y1][y2][k - 1];
for (int u = 0; u < int(q); u++) {
int x1, x2, y1, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
long long ans = d[x2 - 1][y1 - 1][y2 - 1][x2 - x1 + 1];
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
string s[41];
bool a[44][44][44][44];
int p[44][44][44][44];
int z[44][44][44][44];
int main() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k <= n; k++) a[i][j][k][0] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k <= m; k++) a[i][j][0][k] = 1;
for (int i = 1; i <= max(n, m); i++) {
for (int j = 1; j <= i; j++) {
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++)
if (a[k][l][i - 1][j] && a[k][l][i][j - 1] &&
s[i + k - 1][j + l - 1] == '0')
a[k][l][i][j] = true;
swap(i, j);
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++)
if (a[k][l][i - 1][j] && a[k][l][i][j - 1] &&
s[i + k - 1][j + l - 1] == '0')
a[k][l][i][j] = true;
swap(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 1; k <= n; k++)
for (int l = 1; l <= m; l++) {
p[i][j][k][l] =
p[i][j][k - 1][l] + p[i][j][k][l - 1] - p[i][j][k - 1][l - 1];
if (a[i][j][k][l]) p[i][j][k][l]++;
}
}
}
for (int x1 = n - 1; x1 >= 0; x1--)
for (int y1 = m - 1; y1 >= 0; y1--)
for (int x2 = n - 1; x2 >= x1; x2--)
for (int y2 = m - 1; y2 >= y1; y2--) {
z[x1][y1][x2][y2] = z[x1 + 1][y1 + 1][x2][y2];
for (int i = y1 + 1; i <= y2; i++)
z[x1][y1][x2][y2] += p[x1][i][x2 - x1 + 1][y2 - i + 1];
for (int i = x1 + 1; i <= x2; i++)
z[x1][y1][x2][y2] += p[i][y1][x2 - i + 1][y2 - y1 + 1];
z[x1][y1][x2][y2] += p[x1][y1][x2 - x1 + 1][y2 - y1 + 1];
}
for (int i = 0; i < q; i++) {
int d, b, c, e;
cin >> b >> c >> d >> e;
int sum = 0;
b--;
c--;
d--;
e--;
cout << z[b][c][d][e] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 50;
int row[Max][Max] = {0}, dp[Max][Max][Max][Max] = {0}, a[Max][Max];
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%1d", &a[i][j]);
row[i][j] = row[i][j - 1] + 1;
if (a[i][j] == 1) row[i][j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = i; k <= n; k++) {
for (int l = j; l <= m; l++) {
dp[i][j][k][l] =
dp[i][j][k - 1][l] + dp[i][j][k][l - 1] - dp[i][j][k - 1][l - 1];
int r = l - j + 1;
for (int z = k; z >= i; z--) {
r = min(r, row[z][l]);
dp[i][j][k][l] += r;
}
}
}
}
}
while (q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
cout << dp[a][b][c][d] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456,268435456")
using namespace std;
int above[41][41], dp[41][41][41][41];
char s[42];
int main() {
int n, m, q, s1, s2, s3, s4;
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++)
if (s[j] == '0') above[i][j] += above[i - 1][j] + 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = i; k <= n; k++)
for (int l = j; l <= m; l++) {
dp[i][j][k][l] =
dp[i][j][k - 1][l] + dp[i][j][k][l - 1] - dp[i][j][k - 1][l - 1];
int temp = min(above[k][l], k - i + 1);
dp[i][j][k][l] += temp;
for (int z = l - 1; z >= j; z--) {
temp = min(temp, above[k][z]);
if (temp == 0)
break;
else
dp[i][j][k][l] += temp;
}
}
for (int i = 0; i < q; i++)
scanf("%d %d %d %d", &s1, &s2, &s3, &s4),
printf("%d\n", dp[s1][s2][s3][s4]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 40 + 10;
const int Mod = 1e9 + 7;
const long long int Inf = 1LL << 62;
int cum[Max][Max];
int cnt[Max][Max][Max][Max];
char ch[Max][Max];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, q, a, b, c, d;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ch[i][j];
cum[i][j] = cum[i][j - 1] + (ch[i][j] == '1');
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int mp[Max] = {0};
for (int k = i; k <= n; k++) {
for (int l = j; l <= m; l++) {
int ans = 0;
for (int m = j; m <= l; m++) {
cnt[i][j][k][l] += mp[m];
}
for (int m = i; m <= k; m++) {
ans += cum[m][l] - cum[m][j - 1];
}
if (ans == 0) {
cnt[i][j][k][l] += 1;
mp[l] += 1;
}
}
}
}
}
while (q--) {
int ans = 0;
cin >> a >> b >> c >> d;
for (int i = a; i <= c; i++) {
for (int j = b; j <= d; j++) {
ans += cnt[i][j][c][d];
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a, b, c, d;
char linha[42][42];
int pd[42][42][42][42];
int doit(int a, int b, int c, int d) {
if (a > c) return 0;
if (b > d) return 0;
if (pd[a][b][c][d] != -1) return pd[a][b][c][d];
int resp = 0;
resp += doit(a + 1, b, c, d);
resp += doit(a, b + 1, c, d);
resp -= doit(a + 1, b + 1, c, d);
int menor = d;
for (int i = a; i <= c; i++) {
if (linha[i][b] == '1') break;
for (int j = b; j <= menor; j++) {
if (linha[i][j] == '1') {
menor = min(menor, j - 1);
break;
}
resp++;
}
}
return pd[a][b][c][d] = resp;
}
int main(void) {
memset(pd, -1, sizeof pd);
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < n; i++) {
scanf("%s", linha[i]);
}
for (int i = 0; i < q; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
a--;
b--;
c--;
d--;
printf("%d\n", doit(a, b, c, d));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool a[41][41];
int d[41][41][41][41];
int cld[41][41][41][41];
int cldh[41][41][41][41];
int lines_y[41][41];
int main() {
int n, m, q;
scanf("%d %d %d\n", &n, &m, &q);
char ch;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%c", &ch);
a[i][j] = ch == '0';
}
scanf("%c", &ch);
}
for (int j = 0; j < m; ++j) {
lines_y[0][j] = a[0][j];
for (int i = 1; i < n; ++i)
lines_y[i][j] = a[i][j] ? lines_y[i - 1][j] + 1 : 0;
}
for (int h = 0; h < n; ++h) {
for (int w = 0; w < m; ++w) {
for (int i = n - h - 1; i >= 0; --i) {
for (int j = m - w - 1; j >= 0; --j) {
if (h == 0 && w == 0) {
d[i][j][h][w] = a[i][j];
cld[i][j][h][w] = a[i][j];
cldh[i][j][h][w] = a[i][j];
} else {
int c1 = h > 0 ? d[i][j][h - 1][w] : 0;
int c2 = w > 0 ? d[i][j][h][w - 1] : 0;
int c3 = w > 0 && h > 0 ? d[i][j][h - 1][w - 1] : 0;
if (!a[i + h][j + w]) {
d[i][j][h][w] = c1 + c2 - c3;
} else {
int cy = min(lines_y[i + h][j + w], h + 1);
int c4 = cy + (w > 0 ? cld[i + h - cy + 1][j][cy - 1][w - 1] : 0);
cldh[i][j][h][w] = cy;
cld[i][j][h][w] = c4;
d[i][j][h][w] = c1 + c2 - c3 + c4;
}
}
}
}
}
}
int x1, y1, x2, y2;
for (int t = 0; t < q; ++t) {
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
printf("%d\n", d[x1 - 1][y1 - 1][x2 - x1][y2 - y1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int dp[42][42][42][42];
int acc[42][42], arr[42][42];
int beut[42][42][42][42];
int sx[] = {-1, 0, -1};
int sy[] = {0, -1, -1};
int solve(int i1, int j1, int i2, int j2) {
if (i2 < i1 || j2 < j1) return 0;
int &ret = dp[i1][j1][i2][j2];
if (ret != -1) return ret;
ret = 0;
ret += beut[i1][j1][i2][j2];
int arr[5] = {0};
for (int mask = 1; mask < 16; mask++) {
int c = 0;
int a = mask;
int ind = 0;
while (a) {
if (a % 2 == 1) {
arr[ind++] = 1;
c++;
} else {
arr[ind++] = 0;
}
a /= 2;
}
int B = solve(i1 + arr[0], j1 + arr[1], i2 - arr[2], j2 - arr[3]);
if (c % 2)
ret += B;
else
ret -= B;
}
return ret;
}
int main() {
cin >> n >> m >> q;
n++;
m++;
string s;
for (int i = 1; i < n; i++) {
cin >> s;
for (int j = 1; j < m; j++) {
arr[i][j] = s[j - 1] - '0';
}
}
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++) {
acc[i][j] = acc[i - 1][j] + acc[i][j - 1] - acc[i - 1][j - 1] + arr[i][j];
}
for (int i1 = 1; i1 < n; i1++)
for (int i2 = i1; i2 < n; i2++)
for (int j1 = 1; j1 < m; j1++)
for (int j2 = j1; j2 < m; j2++) {
int sum = acc[i2][j2] + acc[i1 - 1][j1 - 1] - acc[i2][j1 - 1] -
acc[i1 - 1][j2];
if (sum == 0) {
beut[i1][j1][i2][j2] = 1;
}
}
memset(dp, -1, sizeof dp);
int a2, a1, b1, b2;
for (int i1 = 1; i1 < n; i1++)
for (int i2 = i1; i2 < n; i2++)
for (int j1 = 1; j1 < m; j1++)
for (int j2 = j1; j2 < m; j2++) solve(i1, j1, i2, j2);
for (int i = 0; i < q; i++) {
cin >> a1 >> b1 >> a2 >> b2;
int ret = solve(a1, b1, a2, b2);
cout << ret << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 40;
int N, M, Q;
int sp[NMAX + 2][NMAX + 2], v[NMAX + 2][NMAX + 2];
int d[NMAX + 2][NMAX + 2][NMAX + 2][NMAX + 2];
int meh[NMAX + 2][NMAX + 2][NMAX + 2][NMAX + 2];
bool OK(int l1, int l2, int c1, int c2) {
int a = l2, x = l1;
int b = c2, y = c1;
int sum = sp[a][b] - sp[a][y - 1] - sp[x - 1][b] + sp[x - 1][y - 1];
return sum == 0;
}
int split_lin(int a, int b, int x, int y) {
return d[a + 1][b][x][y] + d[a][b - 1][x][y] - d[a + 1][b - 1][x][y] +
OK(a, b, x, y);
}
int split_col(int a, int b, int x, int y) {
return d[a][b][x + 1][y] + d[a][b][x][y - 1] - d[a][b][x + 1][y - 1] +
OK(a, b, x, y);
}
int split(int a, int b, int x, int y) {
int A = a + 1, B = b - 1, X = x + 1, Y = y - 1;
return d[A][b][x][y] + d[a][B][x][y] + d[a][b][X][y] + d[a][b][x][Y] -
d[A][B][x][y] - d[A][b][X][y] - d[A][b][x][Y] - d[a][B][X][y] -
d[a][B][x][Y] - d[a][b][X][Y] + d[A][B][X][y] + d[A][B][x][Y] +
d[A][b][X][Y] + d[a][B][X][Y] - d[A][B][X][Y];
}
int main() {
cin >> N >> M >> Q;
for (int i = 1; i <= N; ++i) {
string str;
cin >> str;
for (int j = 1; j <= M; ++j) {
v[i][j] = (str[j - 1] == '1');
sp[i][j] = v[i][j] + sp[i - 1][j] + sp[i][j - 1] - sp[i - 1][j - 1];
}
}
for (int dx = 0; dx < N; ++dx) {
for (int dy = 0; dy < M; ++dy) {
for (int a = 1; a <= N; ++a) {
if (a + dx > N) break;
for (int x = 1; x <= M; ++x) {
if (x + dy > M) break;
int b = a + dx;
int y = x + dy;
if (dx == 0) {
meh[a][b][x][y] = OK(a, b, x, y);
} else if (dx == 1) {
meh[a][b][x][y] =
OK(a, b, x, y) + OK(a + 1, b, x, y) + OK(a, b - 1, x, y);
} else if (dx >= 2) {
meh[a][b][x][y] = meh[a][b - 1][x][y] + meh[a + 1][b][x][y] -
meh[a + 1][b - 1][x][y];
}
}
}
}
}
for (int dx = 0; dx < N; ++dx) {
for (int dy = 0; dy < M; ++dy) {
for (int a = 1; a <= N; ++a) {
if (a + dx > N) break;
for (int x = 1; x <= M; ++x) {
if (x + dy > M) break;
int b = a + dx;
int y = x + dy;
if (dx == 0) {
if (dy == 0)
d[a][b][x][y] = OK(a, b, x, y);
else if (dy == 1)
d[a][b][x][y] = OK(a, b, x, x) + OK(a, b, y, y) + OK(a, b, x, y);
else if (dy >= 2) {
d[a][b][x][y] = split_col(a, b, x, y);
}
} else if (dx == 1) {
if (dy == 0)
d[a][b][x][y] = OK(a, a, x, y) + OK(b, b, x, y) + OK(a, b, x, y);
else if (dy == 1) {
d[a][b][x][y] = OK(a, a, x, x) + OK(b, b, x, x) + OK(a, a, y, y) +
OK(b, b, y, y) + OK(a, b, x, x) + OK(a, b, y, y) +
OK(a, a, x, y) + OK(b, b, x, y) + OK(a, b, x, y);
} else if (dy >= 2) {
d[a][b][x][y] =
split_col(a, b, x, y) + OK(a, a, x, y) + OK(b, b, x, y);
}
} else if (dx >= 2) {
if (dy == 0)
d[a][b][x][y] = split_lin(a, b, x, y);
else if (dy == 1)
d[a][b][x][y] =
split_lin(a, b, x, y) + OK(a, b, x, x) + OK(a, b, y, y);
else if (dy >= 2) {
d[a][b][x][y] = split(a, b, x, y) + OK(a, b, x, y);
}
}
}
}
}
}
while (Q--) {
int a, b, c, d1;
cin >> a >> b >> c >> d1;
cout << d[a][c][b][d1] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 41;
int dp[N][N][N][N];
char arr[N][N];
int cum[N][N];
int n, m, q;
bool allZeros(int i, int j, int x, int y) {
int lenA = x - i + 1, lenB = y - j + 1, tot = lenA * lenB;
return tot == (cum[x][y] - cum[x][j - 1] - cum[i - 1][y] + cum[i - 1][j - 1]);
}
int solve(int i, int j, int x, int y) {
if (x < i || y < j) return 0;
if (dp[i][j][x][y] != -1) return dp[i][j][x][y];
return dp[i][j][x][y] =
(0LL + allZeros(i, j, x, y) + solve(i, j + 1, x, y) +
solve(i, j, x, y - 1) + solve(i + 1, j, x, y) +
solve(i, j, x - 1, y) - solve(i, j + 1, x, y - 1) -
solve(i + 1, j + 1, x, y) - solve(i, j + 1, x - 1, y) -
solve(i, j, x - 1, y - 1) - solve(i + 1, j, x, y - 1) -
solve(i + 1, j, x - 1, y) + solve(i, j + 1, x - 1, y - 1) +
solve(i + 1, j + 1, x, y - 1) + solve(i + 1, j + 1, x - 1, y) +
solve(i + 1, j, x - 1, y - 1) -
solve(i + 1, j + 1, x - 1, y - 1));
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", arr[i] + 1);
for (int j = 1; j <= m; j++) {
cum[i][j] = cum[i - 1][j] + cum[i][j - 1] - cum[i - 1][j - 1] +
(arr[i][j] == '0');
}
}
memset(dp, -1, sizeof dp);
while (q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", solve(a, b, c, d));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[55][55], d[55][55], dd[55][55][55][55], ans[55][55][55][55], i, j,
k[55][55][55][55], l, m, n;
char c;
int ss(int i, int j, int i1, int j1) {
return ((d[i1][j1] - d[i1][j - 1] - d[i - 1][j1] + d[i - 1][j - 1]) == 0);
}
int main() {
int m1;
cin >> n >> m >> m1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> c, a[i][j] = c - '0';
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
d[i][j] = d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1] + a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int i1 = i; i1 >= 1; i1--)
for (int j1 = j; j1 >= 1; j1--) {
k[i1][j1][i][j] = ss(i1, j1, i, j) + k[i1][j1 + 1][i][j] +
k[i1 + 1][j1][i][j] - k[i1 + 1][j1 + 1][i][j];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int i1 = i; i1 <= n; i1++)
for (int j1 = j; j1 <= m; j1++) {
ans[i][j][i1][j1] = ans[i][j][i1 - 1][j1] + ans[i][j][i1][j1 - 1] -
ans[i][j][i1 - 1][j1 - 1] + k[i][j][i1][j1];
}
while (m1--) {
int i, j, i1, j1;
cin >> i >> j >> i1 >> j1;
cout << ans[i][j][i1][j1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 40;
int n, m, q;
int a[MAXN][MAXN];
int ans[MAXN][MAXN][MAXN][MAXN];
void precompute(int x1, int y1) {
vector<int> d(m, x1 - 1);
for (int i = x1; i < n; i++) {
for (int j = y1; j < m; j++) {
if (a[i][j] == 1) {
d[j] = i;
}
}
int cur = 0;
int res = 0;
stack<pair<int, int> > st;
for (int j = y1; j < m; j++) {
while (!st.empty() && d[st.top().first] <= d[j]) {
cur -= st.top().second;
st.pop();
}
int lg = (st.empty() ? y1 - 1 : st.top().first);
st.push(make_pair(j, (i - d[j]) * (j - lg)));
cur += (i - d[j]) * (j - lg);
res += cur;
ans[x1][y1][i][j] = res + (i > x1 ? ans[x1][y1][i - 1][j] : 0);
}
}
}
int main() {
scanf("%d %d %d\n", &n, &m, &q);
char c;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%c", &c);
if (c == '0') {
a[i][j] = 0;
} else {
a[i][j] = 1;
}
}
scanf("%c", &c);
}
for (int ug = 0; ug < n; ug++) {
for (int lg = 0; lg < m; lg++) {
precompute(ug, lg);
}
}
for (int i = 0; i < q; i++) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
printf("%d\n", ans[x1 - 1][y1 - 1][x2 - 1][y2 - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, q;
cin >> n >> m >> q;
vector<string> f(n);
for (int i = 0; i < n; ++i) cin >> f[i];
int t[n][m][n][m];
memset(t, sizeof(int) * n * m * n * m, 0);
char a[n][m][n][m];
memset(a, sizeof(char) * n * m * n * m, 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
a[i][j][i][j] = (f[i][j] == '0');
t[i][j][i][j] = (f[i][j] == '0');
for (int k = i; k >= 0; --k) {
for (int l = j; l >= 0; --l) {
if (k == i && l == j) continue;
a[i][j][k][l] = (f[k][l] == '0') &&
(k < i ? a[i][j][k + 1][l] : true) &&
(l < j ? a[i][j][k][l + 1] : true);
t[i][j][k][l] = (k < i ? t[i][j][k + 1][l] : 0) +
(l < j ? t[i][j][k][l + 1] : 0) -
(k < i && l < j ? t[i][j][k + 1][l + 1] : 0) +
a[i][j][k][l];
}
}
}
}
for (int i = 0; i < q; ++i) {
int a, b, c, d;
cin >> a >> b >> c >> d;
--a;
--b;
--c;
--d;
int res = 0;
for (int k = a; k <= c; ++k) {
for (int l = b; l <= d; ++l) {
res += t[k][l][a][b];
}
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a[50][50];
int f[50][50], cnt[45][45][45][45];
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char ch = getchar();
while (ch != '0' && ch != '1') ch = getchar();
a[i][j] = (ch == '1');
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) {
if (i == 0 && j == 0)
f[i][j] = a[i][j];
else
f[i][j] = f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1] + a[i][j];
}
for (int xa = 1; xa <= n; xa++)
for (int ya = 1; ya <= m; ya++)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++) {
int sum =
f[xb][yb] - f[xa - 1][yb] - f[xb][ya - 1] + f[xa - 1][ya - 1];
if (sum == 0) cnt[xa][ya][xb][yb] = 1;
}
for (int xa = n; xa >= 2; xa--)
for (int ya = 1; ya <= m; ya++)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++)
cnt[xa - 1][ya][xb][yb] += cnt[xa][ya][xb][yb];
for (int xa = 1; xa <= n; xa++)
for (int ya = m; ya >= 2; ya--)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++)
cnt[xa][ya - 1][xb][yb] += cnt[xa][ya][xb][yb];
for (int xa = 1; xa <= n; xa++)
for (int ya = 1; ya <= m; ya++)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++)
cnt[xa][ya][xb + 1][yb] += cnt[xa][ya][xb][yb];
for (int xa = 1; xa <= n; xa++)
for (int ya = 1; ya <= m; ya++)
for (int xb = xa; xb <= n; xb++)
for (int yb = ya; yb <= m; yb++)
cnt[xa][ya][xb][yb + 1] += cnt[xa][ya][xb][yb];
int k1, k2, k3, k4;
while (q--) {
scanf("%d%d%d%d", &k1, &k2, &k3, &k4);
printf("%d\n", cnt[k1][k2][k3][k4]);
}
return 0;
}
|
#include <bits/stdc++.h>
char a[50][50];
int s[50][50], f[50][50][50], g[50][50][50], ans[50][50][50][50];
inline bool check(int x0, int y0, int x1, int y1) {
int sum = s[x1][y1] - s[x0 - 1][y1] - s[x1][y0 - 1] + s[x0 - 1][y0 - 1];
return (sum == (x1 - x0 + 1) * (y1 - y0 + 1));
}
int main() {
int n, m, Q;
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= n; i++) scanf("%s", a[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + (a[i][j] == '0');
for (int x = n; x; x--)
for (int y = m; y; y--) {
for (int i = x; i <= n; i++)
for (int j = y; j <= m; j++) {
f[y][i][j] += check(x, y, i, j);
g[y][i][j] = g[y + 1][i][j] + f[y][i][j];
}
int tmp[50] = {0};
for (int i = x; i <= n; i++)
for (int j = y; j <= m; j++) {
tmp[j] += g[y][i][j];
ans[x][y][i][j] = ans[x][y][i][j - 1] + tmp[j];
}
}
while (Q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", ans[a][b][c][d]);
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
char c[50][50], a[50][50];
int sum[50][50], cnt[50][50][50][50];
bool isGood(int xa, int ya, int xb, int yb) {
return sum[xa][ya] - sum[xa][yb] - sum[xb][ya] + sum[xb][yb] == 0;
}
int main() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> c[i][j];
a[i][j] = c[i][j] - '0';
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
sum[i + 1][j + 1] = sum[i][j + 1] + sum[i + 1][j] - sum[i][j] + a[i][j];
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int ii = i + 1; ii <= n; ii++)
for (int jj = j + 1; jj <= m; jj++)
cnt[i][j][ii + 1][jj + 1] =
cnt[i][j][ii + 1][jj] + cnt[i][j][ii][jj + 1] -
cnt[i][j][ii][jj] + (isGood(i, j, ii, jj) ? 1 : 0);
int k1, k2, k3, k4;
for (int i = 0; i < q; i++) {
scanf("%d%d%d%d", &k1, &k2, &k3, &k4);
int ans = 0;
k1--, k2--;
for (int j = k1; j < k3; j++)
for (int l = k2; l < k4; l++) {
ans += cnt[j][l][k3 + 1][k4 + 1];
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const double pi = 2 * asin(1.0);
int n;
int m;
int a[50][50];
int s[42][42], f[42][42][42][42], g[42][42][42][42], h[42][42][42][42];
int main() {
int q;
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 1; j <= m; j++) a[i][j] = s[j - 1] - '0';
}
for (int i = n; i >= 1; i--)
for (int j = m; j >= 1; j--) {
s[i][j] = s[i + 1][j] + s[i][j + 1] - s[i + 1][j + 1] + a[i][j];
for (int k = i; k <= n; k++)
for (int l = j; l <= m; l++) {
f[i][j][k][l] =
int((s[i][j] - s[k + 1][j] - s[i][l + 1] + s[k + 1][l + 1]) == 0);
g[i][j][k][l] = g[i][j][k - 1][l] + g[i][j][k][l - 1] -
g[i][j][k - 1][l - 1] + f[i][j][k][l];
h[i][j][k][l] = h[i + 1][j][k][l] + h[i][j + 1][k][l] -
h[i + 1][j + 1][k][l] + g[i][j][k][l];
}
}
for (int i = 0; i < q; i++) {
int x1, x2, y8687969, y2;
scanf("%d%d%d%d", &x1, &y8687969, &x2, &y2);
printf("%d\n", h[x1][y8687969][x2][y2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 45;
int n, m, q, mat[N][N], dp[N][N][N][N];
char arr[N][N];
bool query(int a, int b, int c, int d) {
int res = mat[c][d];
if (a) res -= mat[a - 1][d];
if (b) res -= mat[c][b - 1];
if (a && b) res += mat[a - 1][b - 1];
return !res;
}
int sol(int a, int b, int c, int d) {
int &ret = dp[a][b][c][d];
if (~ret) return ret;
ret = query(a, b, c, d);
if (c > a) ret += sol(a, b, c - 1, d);
if (d > b) ret += sol(a, b, c, d - 1);
if (c > a && d > b) ret -= sol(a, b, c - 1, d - 1);
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> arr[i][j];
for (int i = 0; i < m; ++i) mat[0][i] = arr[0][i] - '0';
for (int i = 1; i < n; ++i)
for (int j = 0; j < m; ++j) mat[i][j] = (arr[i][j] - '0') + mat[i - 1][j];
for (int i = 0; i < n; ++i)
for (int j = 1; j < m; ++j) mat[i][j] += mat[i][j - 1];
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
--a, --b, --c, --d;
int ans = 0;
for (int i = a; i <= c; ++i)
for (int j = b; j <= d; ++j) ans += sol(i, j, c, d);
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 41;
int n, m, q, cor[M][M][M][M], dp[M][M][M][M], lf[M][M];
char mp[M][M];
bool mark[M][M][M][M];
void prec() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int k = j; k >= 1; k--)
if (mp[i][k] == '1')
break;
else
lf[i][j]++;
}
}
int mem(int a, int b, int c, int d) {
if (mark[a][b][c][d]) return dp[a][b][c][d];
mark[a][b][c][d] = true;
if (a == 0 || b == 0 || c == 0 || d == 0 || d < b || c < a) return 0;
if (mp[c][d] == '0') {
int bb = max(b, d - lf[c][d] + 1);
mem(a, bb, c - 1, d);
cor[a][b][c][d] = cor[a][bb][c - 1][d] + min(d - b + 1, lf[c][d]);
}
dp[a][b][c][d] = mem(a, b, c - 1, d) + mem(a, b, c, d - 1) -
mem(a, b, c - 1, d - 1) + cor[a][b][c][d];
return dp[a][b][c][d];
}
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
scanf("%c", &mp[0][0]);
for (int j = 1; j <= m; j++) scanf("%c", &mp[i][j]);
}
prec();
while (q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", mem(a, b, c, d));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int matr[40][40];
int N, M, Q;
int S[40][40][40][40];
int f(int x1, int y1, int x2, int y2) {
int res = matr[x2][y2];
if (x1 > 0) res -= matr[x1 - 1][y2];
if (y1 > 0) res -= matr[x2][y1 - 1];
if (x1 > 0 && y1 > 0) res += matr[x1 - 1][y1 - 1];
return res;
}
int main() {
scanf("%d%d%d", &N, &M, &Q);
for (int i = 0; i < N; i++) {
char s[100];
scanf("%s", s);
for (int j = 0; j < M; j++) matr[i][j] = s[j] - '0';
}
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
if (i > 0) matr[i][j] += matr[i - 1][j];
if (j > 0) matr[i][j] += matr[i][j - 1];
if (i > 0 && j > 0) matr[i][j] -= matr[i - 1][j - 1];
}
memset(S, 0, sizeof(int) * 40 * 40 * 40 * 40);
for (int i1 = 0; i1 < N; i1++)
for (int i2 = i1; i2 < N; i2++)
for (int j1 = 0; j1 < M; j1++)
for (int j2 = j1; j2 < M; j2++) {
S[i1][j1][i2][j2] = ((f(i1, j1, i2, j2) == 0) ? 1 : 0);
}
for (int i1 = 0; i1 < N; i1++)
for (int j1 = 0; j1 < M; j1++)
for (int i2 = i1; i2 < N; i2++)
for (int j2 = j1; j2 < M; j2++) {
if (i2 > 0) S[i1][j1][i2][j2] += S[i1][j1][i2 - 1][j2];
if (j2 > 0) S[i1][j1][i2][j2] += S[i1][j1][i2][j2 - 1];
if (i2 > 0 && j2 > 0) S[i1][j1][i2][j2] -= S[i1][j1][i2 - 1][j2 - 1];
}
for (int i1 = N - 1; i1 >= 0; i1--)
for (int j1 = M - 1; j1 >= 0; j1--)
for (int i2 = i1; i2 < N; i2++)
for (int j2 = j1; j2 < M; j2++) {
if (i1 + 1 < N) S[i1][j1][i2][j2] += S[i1 + 1][j1][i2][j2];
if (j1 + 1 < M) S[i1][j1][i2][j2] += S[i1][j1 + 1][i2][j2];
if (i1 + 1 < N && j1 + 1 < M)
S[i1][j1][i2][j2] -= S[i1 + 1][j1 + 1][i2][j2];
}
for (int i = 0; i < Q; i++) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
x1--;
y1--;
x2--;
y2--;
printf("%d\n", S[x1][y1][x2][y2]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double EPS = 1e-7;
const int inf = 1e9;
const long long INF = 2e18;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int dp[42][42][42][42] = {0};
int main() {
int n, m, q;
cin >> n >> m >> q;
vector<string> in(n);
for (int i = 0; i < n; i++) cin >> in[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int t = m + 1;
for (int k = i + 1; k < n + 1; k++)
for (int l = j + 1; l < t; l++)
if (in[k - 1][l - 1] == '0')
dp[i][j][k][l] = 1;
else
t = l;
}
for (int i = 0; i < 42; i++)
for (int j = 0; j < 42; j++)
for (int k = 0; k < 42; k++)
for (int l = 0; l < 42; l++) {
if (k && l)
dp[i][j][k][l] += dp[i][j][k - 1][l] + dp[i][j][k][l - 1] -
dp[i][j][k - 1][l - 1];
}
for (int k = n; k > 0; k--)
for (int l = m; l > 0; l--)
for (int i = n - 1; i >= 0; i--)
for (int j = m - 1; j >= 0; j--) {
if (in[i][j] == '1') dp[i][j][k][l] = 0;
dp[i][j][k][l] +=
dp[i][j + 1][k][l] + dp[i + 1][j][k][l] - dp[i + 1][j + 1][k][l];
}
while (q--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << dp[a - 1][b - 1][c][d] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int dp[42][42][42][42];
int acc[42][42], arr[42][42];
int beut[42][42][42][42];
int sx[] = {-1, 0, -1};
int sy[] = {0, -1, -1};
int solve(int i1, int j1, int i2, int j2) {
if (i2 < i1 || j2 < j1) return 0;
int &ret = dp[i1][j1][i2][j2];
if (ret != -1) return ret;
ret = 0;
ret += beut[i1][j1][i2][j2];
int arr[5] = {0};
for (int mask = 1; mask < 16; mask++) {
int c = 0;
int a = mask;
int ind = 0;
while (a) {
if (a % 2 == 1) {
arr[ind++] = 1;
c++;
} else {
arr[ind++] = 0;
}
a /= 2;
}
int B = solve(i1 + arr[0], j1 + arr[1], i2 - arr[2], j2 - arr[3]);
if (c % 2)
ret += B;
else
ret -= B;
}
return ret;
}
int main() {
cin >> n >> m >> q;
n++;
m++;
string s;
for (int i = 1; i < n; i++) {
cin >> s;
for (int j = 1; j < m; j++) {
arr[i][j] = s[j - 1] - '0';
}
}
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++) {
acc[i][j] = acc[i - 1][j] + acc[i][j - 1] - acc[i - 1][j - 1] + arr[i][j];
}
for (int i1 = 1; i1 < n; i1++)
for (int i2 = i1; i2 < n; i2++)
for (int j1 = 1; j1 < m; j1++)
for (int j2 = j1; j2 < m; j2++) {
int sum = acc[i2][j2] + acc[i1 - 1][j1 - 1] - acc[i2][j1 - 1] -
acc[i1 - 1][j2];
if (sum == 0) {
beut[i1][j1][i2][j2] = 1;
}
}
memset(dp, -1, sizeof dp);
int a2, a1, b1, b2;
for (int i1 = 1; i1 < n; i1++)
for (int i2 = i1; i2 < n; i2++)
for (int j1 = 1; j1 < m; j1++)
for (int j2 = j1; j2 < m; j2++) solve(i1, j1, i2, j2);
for (int i = 0; i < q; i++) {
cin >> a1 >> b1 >> a2 >> b2;
int ret = dp[a1][b1][a2][b2];
cout << ret << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int a[(1 << 6)][(1 << 6)];
int pre[(1 << 6)][(1 << 6)];
int ggd[(1 << 6)][(1 << 6)][(1 << 6)][(1 << 6)];
int Ans[(1 << 6)][(1 << 6)][(1 << 6)][(1 << 6)];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char cc = getchar();
while (cc != '0' && cc != '1') {
cc = getchar();
}
a[i][j] = cc - '0';
pre[i + 1][j + 1] = pre[i][j + 1] + pre[i + 1][j] - pre[i][j] + a[i][j];
}
}
for (int xx1 = 0; xx1 < n; xx1++) {
for (int xx2 = xx1; xx2 < n; xx2++) {
for (int yy1 = 0; yy1 < m; yy1++) {
for (int yy2 = yy1; yy2 < m; yy2++) {
if (pre[xx2 + 1][yy2 + 1] - pre[xx2 + 1][yy1] - pre[xx1][yy2 + 1] +
pre[xx1][yy1] ==
0) {
ggd[xx1][yy1][xx2][yy2] = 1;
}
}
}
}
}
for (int xx1 = 0; xx1 < n; xx1++) {
for (int yy1 = 0; yy1 < m; yy1++) {
for (int xx2 = 0; xx2 < n; xx2++) {
for (int yy2 = 0; yy2 < m; yy2++) {
Ans[xx1 + 1][yy1 + 1][xx2 + 1][yy2 + 1] =
Ans[xx1][yy1 + 1][xx2 + 1][yy2 + 1] +
Ans[xx1 + 1][yy1][xx2 + 1][yy2 + 1] +
Ans[xx1 + 1][yy1 + 1][xx2][yy2 + 1] +
Ans[xx1 + 1][yy1 + 1][xx2 + 1][yy2] -
Ans[xx1][yy1][xx2 + 1][yy2 + 1] -
Ans[xx1][yy1 + 1][xx2][yy2 + 1] -
Ans[xx1][yy1 + 1][xx2 + 1][yy2] -
Ans[xx1 + 1][yy1][xx2][yy2 + 1] -
Ans[xx1 + 1][yy1][xx2 + 1][yy2] -
Ans[xx1 + 1][yy1 + 1][xx2][yy2] + Ans[xx1 + 1][yy1][xx2][yy2] +
Ans[xx1][yy1 + 1][xx2][yy2] + Ans[xx1][yy1][xx2 + 1][yy2] +
Ans[xx1][yy1][xx2][yy2 + 1] - Ans[xx1][yy1][xx2][yy2] +
ggd[xx1][yy1][xx2][yy2];
}
}
}
}
while (q--) {
int xx1, yy1, xx2, yy2;
scanf("%d%d%d%d", &xx1, &yy1, &xx2, &yy2);
xx1--, yy1--, xx2--, yy2--;
printf(
"%d\n",
Ans[xx2 + 1][yy2 + 1][xx2 + 1][yy2 + 1] -
Ans[xx1][yy2 + 1][xx2 + 1][yy2 + 1] -
Ans[xx2 + 1][yy1][xx2 + 1][yy2 + 1] -
Ans[xx2 + 1][yy2 + 1][xx1][yy2 + 1] -
Ans[xx2 + 1][yy2 + 1][xx2 + 1][yy1] +
Ans[xx1][yy1][xx2 + 1][yy2 + 1] + Ans[xx1][yy2 + 1][xx1][yy2 + 1] +
Ans[xx1][yy2 + 1][xx2 + 1][yy1] + Ans[xx2 + 1][yy1][xx1][yy2 + 1] +
Ans[xx2 + 1][yy1][xx2 + 1][yy1] + Ans[xx2 + 1][yy2 + 1][xx1][yy1] -
Ans[xx2 + 1][yy1][xx1][yy1] - Ans[xx1][yy2 + 1][xx1][yy1] -
Ans[xx1][yy1][xx2 + 1][yy1] - Ans[xx1][yy1][xx1][yy2 + 1] +
Ans[xx1][yy1][xx1][yy1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int above[41][41];
int dp[41][41][41][41];
int main() {
int n, m, q, s1, s2, s3, s4;
char s[42];
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++)
if (s[j] == '0') above[i][j] = above[i - 1][j] + 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = i; k <= n; k++)
for (int l = j; l <= m; l++) {
dp[i][j][k][l] =
dp[i][j][k - 1][l] + dp[i][j][k][l - 1] - dp[i][j][k - 1][l - 1];
int temp = min(k - i + 1, above[k][l]);
for (int p = l; p >= j; p--) {
temp = min(temp, above[k][p]);
if (temp == 0)
break;
else
dp[i][j][k][l] += temp;
}
}
for (int i = 0; i < q; i++)
scanf("%d %d %d %d", &s1, &s2, &s3, &s4),
printf("%d\n", dp[s1][s2][s3][s4]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
int dp[N + 10][N + 10][N + 10][N + 10];
int c[N + 10][N + 10][N + 10];
char a[N + 10][N + 10];
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i1 = 1; i1 <= n; i1++)
for (int j1 = 1; j1 <= m; j1++) {
memset(c, 0, sizeof c);
for (int i = i1; i <= n; i++)
for (int j = j1; j <= m; j++) {
dp[i1][j1][i][j] = dp[i1][j1][i - 1][j] + dp[i1][j1][i][j - 1] -
dp[i1][j1][i - 1][j - 1];
for (int x = i; x >= i1; x--) {
if (a[x][j] != '0') break;
c[i][j][x] = c[i][j - 1][x] + 1;
dp[i1][j1][i][j] += c[i][j][x];
}
}
}
while (q--) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << dp[x1][y1][x2][y2] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[502][22 * 502];
int n;
vector<int> v;
bool use[100000];
vector<long long int> prime;
long long int ans = 1;
long long int ff[30000];
long long int ppow(long long int i, long long int j) {
long long int r = 1;
while (j > 0) {
if (j & 1) {
r *= i;
r %= 1000000007;
}
i *= i;
i %= 1000000007;
j >>= 1;
}
return r % 1000000007;
}
long long int c(long long int a, long long int b) {
long long int m = ff[a];
m = m * ppow(ff[a - b], 1000000007 - 2);
m %= 1000000007;
long long int h = ff[b];
long long int r = m * ppow(h, 1000000007 - 2);
r %= 1000000007;
return r;
}
int main() {
ff[0] = 1;
for (int i = 1; i < 30000; i++) {
ff[i] = ff[i - 1];
ff[i] *= (long long int)i;
ff[i] %= 1000000007;
}
scanf("%d", &n);
prime.push_back(2);
for (int i = 3; i < 100000; i += 2) {
if (use[i] == false) {
prime.push_back(i);
for (int j = i * 2; j < 100000; j += i) {
use[j] = true;
}
}
}
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
for (int i = 0; i < prime.size() && prime[i] * prime[i] <= a; i++) {
while (a % prime[i] == 0) {
v.push_back(prime[i]);
a /= prime[i];
}
}
if (a != 1) {
v.push_back(a);
}
}
sort(v.begin(), v.end());
{
int i = 0;
while (i < v.size()) {
long long int k = v[i];
int countt = 0;
while (i < v.size() && v[i] == k) {
i++;
countt++;
}
ans *= c(countt + n - 1, countt);
ans %= 1000000007;
}
}
ans %= 1000000007;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> factors, p;
long long f[100010];
bool x[32000];
long long bigpow(long long x, long long n) {
if (n == 0) return 1;
long long temp = bigpow(x, n / 2);
return n % 2 == 0 ? (temp * temp) % 1000000007
: (x * ((temp * temp) % 1000000007)) % 1000000007;
}
void _factorize(long long n) {
long long i, j;
for (i = 0; i < p.size(); i++) {
while (n % p[i] == 0) {
n /= p[i];
factors.push_back(p[i]);
}
}
if (n > 1) factors.push_back(n);
}
long long nCr(long long n, long long r) {
long long nf = f[n], rf = bigpow(f[r], 1000000007 - 2) % 1000000007,
n_rf = bigpow(f[n - r], 1000000007 - 2) % 1000000007;
return ((nf * rf) % 1000000007 * n_rf) % 1000000007;
}
int main() {
long long i, j, k, sum = 1, temp, n;
for (i = 0; i < (32000); i++) x[i] = true;
for (i = (2); i < (32000); i++) {
if (x[i]) {
p.push_back(i);
for (j = i; j < 32000; j += i) x[j] = false;
}
}
f[0] = 1;
for (i = (1); i < (100001); i++) f[i] = (f[i - 1] * i) % 1000000007;
scanf("%I64d", &n);
for (i = 0; i < (n); i++) {
scanf("%I64d", &k);
_factorize(k);
}
sort((factors).begin(), (factors).end());
temp = 1;
factors.push_back(1 << 30);
for (i = 1; i < factors.size(); i++) {
if (factors[i] == factors[i - 1])
temp++;
else {
sum = (sum * nCr(temp + n - 1, n - 1)) % 1000000007;
temp = 1;
}
}
printf("%I64d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long fp(long long b, long long p) {
if (!p) return 1;
if (p % 2 == 0) return fp((b * b) % mod, p / 2);
return (b * fp(b, p - 1)) % mod;
}
long long f(long long n, long long r) {
long long aye = 1, you = 1;
for (int i = 0; i < r; i++) {
aye = (aye * (n - i)) % mod;
you = (you * (i + 1)) % mod;
}
return (aye * fp(you, mod - 2)) % mod;
}
int main() {
int n;
while (cin >> n) {
long long var;
long long ans = 1;
map<long long, int> pf;
map<long long, int>::iterator it;
for (int i = 0; i < n; i++) {
cin >> var;
for (int j = 2; j * j <= var && var != 1; j++) {
while (var % j == 0) {
pf[j]++;
var /= j;
}
}
if (var != 1) pf[var]++;
}
for (it = pf.begin(); it != pf.end(); it++) {
ans = (ans * f(it->second + n - 1, n - 1)) % mod;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long x;
long long fact[100005], inv_fact[100005];
map<long long, long long> memo;
void decomp(long long n) {
long long i = 2;
while (i * i <= n) {
while (n % i == 0) {
if (memo.find(i) == memo.end()) {
memo[i] = 1;
} else {
++memo[i];
}
n /= i;
}
++i;
}
if (n != 1) {
if (memo.find(n) == memo.end()) {
memo[n] = 1;
} else {
++memo[n];
}
}
}
long long my_pow(long long a, long long b) {
long long ret = 1;
while (b > 0) {
if (b % 2 == 1) {
ret = (ret * a) % 1000000007;
}
a = (a * a) % 1000000007;
b /= 2;
}
return (ret);
}
long long inv(long long a) { return (my_pow(a, 1000000007 - 2)); }
long long sum(long long n) { return (n * (n - 1) / 2); }
long long comb(long long n, long long m) {
long long ret = (fact[n] * inv_fact[m]) % 1000000007;
ret = (ret * inv_fact[n - m] + 1000000007) % 1000000007;
return (ret);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
cin >> x;
decomp(x);
}
if (n == 1) {
printf("1\n");
exit(0);
}
fact[0] = 1;
inv_fact[0] = inv(fact[0]);
for (int i = 1; i < 100005; ++i) {
fact[i] = (i * fact[i - 1]) % 1000000007;
inv_fact[i] = inv(fact[i]);
}
long long ans = 1;
for (auto c : memo) {
ans = (ans * comb(c.second + n - 1, n - 1)) % 1000000007;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
long long C[15000][501];
int v[1000000], t;
long long comb(int n, int k) {
if (n < k) return 0LL;
if (!k || n == k) return 1LL;
if (C[n][k] >= 0LL) return C[n][k];
C[n][k] = comb(n - 1, k - 1) + comb(n - 1, k);
if (C[n][k] >= mod) C[n][k] -= mod;
return C[n][k];
}
int main() {
cin.sync_with_stdio(false);
memset(C, -1, sizeof(C));
int k;
cin >> k;
t = 0;
for (int i = 0; i < k; i++) {
int d;
cin >> d;
for (int j = 2; j * j <= d; j++)
while (d % j == 0) {
v[t++] = j;
d /= j;
}
if (d > 1) v[t++] = d;
}
if (!t) {
cout << 1 << endl;
return 0;
}
sort(v, v + t);
long long ans = 1LL;
int n = 1;
for (int i = 1; i < t; i++) {
if (v[i] == v[i - 1])
n++;
else {
ans *= comb(n + k - 1, k - 1);
ans %= mod;
n = 1;
}
}
ans *= comb(n + k - 1, k - 1);
ans %= mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int C[18000][501];
map<long long int, long long int> mp;
void factorize(long long int n) {
for (long long int i = 2; i * i <= n; i++)
while (n % i == 0) mp[i]++, n /= i;
if (n > 1) mp[n]++;
}
void solve() {
for (long long int i = 0; i < 18000; i++) {
for (long long int j = 0; j <= min(i, 500LL); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
;
}
}
long long int n, x, ans = 1;
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> x;
factorize(x);
}
for (auto m : mp) {
ans *= C[m.second + n - 1][n - 1];
ans %= 1000000007;
;
}
cout << ans;
}
int main() {
std::ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long d, push, q;
void extendedEuclid(long long A, long long B) {
if (B == 0) {
d = A;
push = 1;
q = 0;
} else {
extendedEuclid(B, A % B);
long long temp = push;
push = q;
q = temp - (A / B) * q;
}
}
long long modInverse(long long A) {
extendedEuclid(A, MOD);
return (push % MOD + MOD) % MOD;
}
long long nCr(long long n, long long c) {
c = min(c, n - c);
long long temp = 1;
for (int i = 1; i <= c; i++) {
temp = temp * (n - i + 1);
temp = temp % MOD;
}
for (int i = 1; i <= c; i++) {
temp = ((temp) % MOD * (modInverse(i)) % MOD) % MOD;
}
return temp;
}
int main() {
long long n;
cin >> n;
long long a[n];
map<long long, long long> make_pair;
for (int i = 0; i < n; i++) {
cin >> a[i];
long long x = a[i];
while (x % 2 == 0) {
x = x / 2;
make_pair[2]++;
}
for (long long j = 3; j * j <= x; j += 2) {
while (x % j == 0) {
x = x / j;
make_pair[j]++;
}
}
if (x != 1) {
make_pair[x]++;
}
}
long long cnt = 1;
for (auto x : make_pair) {
long long temp = nCr(x.second + n - 1, n - 1);
temp = temp % MOD;
cnt = ((cnt) % MOD * (temp) % MOD) % MOD;
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long C[30 * 500 + 47][547];
unsigned long long mod = 1000000007LL;
vector<unsigned long long> get_primes() {
vector<unsigned long long> ans;
int arr[100000];
for (int i = 0; i < 100000; i++) arr[i] = 0;
for (int i = 2; i < 100000; i++)
if (arr[i] == 0)
for (int j = 2; i * j < 100000; j++) arr[i * j] = 1;
for (int i = 2; i < 100000; i++)
if (arr[i] == 0) ans.push_back(i);
return ans;
}
int main() {
iostream::sync_with_stdio(false);
unsigned long long n;
cin >> n;
vector<unsigned long long> primes = get_primes(), input(n);
for (int i = 0; i < n; i++) cin >> input[i];
for (unsigned long long x = 0; x < 30 * 500 + 47; x++)
for (unsigned long long y = 0; y < 547; y++)
if ((x == 0) || (y == 0))
C[x][y] = 1;
else
C[x][y] = (C[x - 1][y] + C[x][y - 1]) % mod;
vector<unsigned long long> factors;
factors.reserve(30 * 500 + 47);
for (int i = 0; i < n; i++) {
for (int j = 0; j < primes.size(); j++)
while (input[i] % primes[j] == 0)
input[i] /= primes[j], factors.push_back(primes[j]);
if (input[i] != 1) factors.push_back(input[i]);
}
sort(factors.begin(), factors.end());
int l = 0, r = 0;
unsigned long long ans = 1;
while (r < factors.size()) {
while ((r != factors.size()) && (factors[l] == factors[r])) r++;
unsigned long long range = r - l;
l = r;
ans = (ans * C[range][n - 1]) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100000, mod = 1000000007;
int n, a, fact[nmax], ans = 1;
map<int, int> f;
int pw(int n, int p) {
if (!p) return 1;
if (p % 2) return (1LL * n * pw(n, p - 1)) % mod;
int x = pw(n, p / 2);
return (1LL * x * x) % mod;
}
int comb(int n, int k) {
int a = fact[n], b = (1LL * fact[k] * fact[n - k]) % mod;
return (1LL * a * pw(b, mod - 2)) % mod;
}
int main() {
fact[0] = 1;
for (int i = 1; i < nmax; ++i) fact[i] = (1LL * fact[i - 1] * i) % mod;
scanf("%i", &n);
for (int i = 1; i <= n; ++i) {
scanf("%i", &a);
int tmp = a;
for (int j = 2; 1LL * j * j <= 1LL * tmp; ++j)
if (tmp % j == 0) {
int exp = 0;
while (tmp % j == 0) tmp /= j, exp++;
f[j] += exp;
}
if (tmp > 1) f[tmp]++;
}
for (map<int, int>::iterator it = f.begin(); it != f.end(); ++it)
ans = (1LL * ans * comb(it->second + n - 1, n - 1)) % mod;
printf("%i\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int c[17000][600];
map<int, int> p;
int b[10000];
int n, a;
int num;
void pr() {
c[0][0] = 1;
for (int i = 1; i < 17000; i++) {
for (int j = 0; j <= i && j < 600; j++) {
if (i == j || j == 0)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % M;
}
}
}
int main() {
pr();
num = 0;
memset(b, 0, sizeof(b));
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
for (int j = 2; j * j <= a; j++) {
if (a % j) continue;
int cnt = 0;
while (a % j == 0) {
cnt++;
a /= j;
}
if (!p[j]) p[j] = ++num;
b[p[j]] += cnt;
}
if (a > 1) {
if (!p[a]) p[a] = ++num;
b[p[a]] += 1;
}
}
long long ans = 1;
for (int i = 1; i <= num; i++) {
ans *= c[b[i] + n - 1][n - 1];
ans = ans % M;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> FCT[510];
int d[510][30 * 510];
set<int> S;
int NEO;
int n;
int MOD = 1000000007;
void gen(int n, map<int, int>& a) {
int sq = 4;
for (auto it = S.begin(); it != S.end(); ++it) {
int i = *it;
while (n % i == 0) {
a[(i)]++;
n /= i;
}
}
while (n % 2 == 0) a[2]++, n /= 2;
sq = 9;
for (int i = 3; i * i <= n; i += 2) {
while (n % i == 0) {
a[(i)]++;
n /= i;
}
}
if (n != 1) a[n]++;
}
int FMOD(int a) {
if (a >= MOD) return a - MOD;
return a;
}
int din(int i, int s) {
if (d[i][s] != -1) return d[i][s];
if (i == n) return (s == 0);
if (s == 0) return 1;
d[i][s] = 0;
int r = s;
d[i][s] = FMOD(din(i + 1, s) + din(i, s - 1));
return d[i][s];
}
int main() {
cin >> n;
for (int i = 0; i < (int)n; i++) {
int a;
scanf("%d", &a);
gen(a, FCT[i]);
for (auto it = FCT[i].begin(); it != FCT[i].end(); ++it) {
S.insert(it->first);
}
}
memset(d, -1, sizeof d);
long long ans = 1;
for (auto it = S.begin(); it != S.end(); it++) {
NEO = *it;
int s = 0;
for (int i = 0; i < (int)n; i++) s += FCT[i][NEO];
assert(s <= 30 * 510);
ans = (ans * din(0, s)) % MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500 + 10;
const int MOD = 1e9 + 7;
int c[MAXN * 32][MAXN];
map<int, int> p;
int main() {
int n, a;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
for (int j = 2; j * j <= a; ++j) {
while (a % j == 0) {
++p[j];
a /= j;
}
}
if (a > 1) {
++p[a];
}
}
for (int i = 0; i < n * 32; ++i) {
c[i][0] = 1;
}
for (int i = 1; i < n * 32; ++i) {
for (int j = 1; j < n; ++j) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
}
}
long long ans = 1;
for (auto it : p) {
ans = (ans * c[it.second + n - 1][n - 1]) % MOD;
}
printf("%d\n", int(ans));
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long INF = 1000LL * 1000 * 1000 * 1000 * 1000 * 1000;
const int inf = 1000 * 1000 * 1000;
const long double PI = acos(-1.0);
const long long mod1 = inf + 7;
const long long mod2 = inf + 9;
const long long bigmod = mod1;
const int MAXN = 1000005;
const long double EPS = 1e-11;
long long hp = inf / 1000 + 3;
const int N = 3e5 + 228;
signed main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
;
int n;
cin >> n;
vector<int> a(n);
for (long long i = 0; i < a.size(); ++i) cin >> a[i];
;
vector<int> cnt(n);
vector<vector<long long>> c(3e4 + 228, vector<long long>(n));
c[1][0] = 1;
for (int i = 1; i <= 30000; ++i) {
c[i][0] = 1;
}
for (int i = 2; i <= 30000; ++i) {
for (int j = 1; j <= min(i, n - 1); ++j) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
c[i][j] %= mod1;
}
}
map<int, int> pr;
for (int i = 0; i < n; ++i) {
int x = a[i];
for (int j = 2; j * j <= x; ++j) {
if (x % j == 0) {
pr[j]++;
x /= j;
j = 1;
}
}
if (x > 1) {
pr[x]++;
}
}
long long ans = 1;
for (auto i : pr) {
ans *= c[i.second + n][n - 1];
ans %= mod1;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 16500, MAXP = 35000, mod = (int)1E9 + 7;
int v[MAXP], primo[MAXP], cont;
long long int inverso;
bool mrk[MAXP];
map<int, int> mp;
void fatora(int N) {
int aa = __builtin_ctz(N);
N /= (1 << aa);
v[0] += aa;
for (int i = 1; primo[i] * primo[i] <= N; i++) {
while (N % primo[i] == 0) {
N /= primo[i];
v[i]++;
}
}
if (N > 1) {
if (mp.find(N) == mp.end()) mp[N] = ++cont;
v[mp[N]]++;
}
}
void calculaprimos() {
mrk[1] = false;
for (int i = 2; i < MAXP; i++) mrk[i] = true;
for (int i = 2; i < MAXP; i++) {
if (mrk[i]) {
for (int k = i * i; k < MAXP; k += i) mrk[k] = false;
}
}
cont = -1;
for (int i = 2; i < MAXP; i++) {
if (mrk[i]) {
primo[++cont] = i;
mp[i] = cont;
}
}
for (int i = 0; i <= cont; i++) v[i] = 0;
}
void calculainverso(int N) {
long long int x = 1LL;
for (int i = 1; i <= N; i++) {
x *= i;
x %= mod;
}
inverso = 1LL;
for (int i = 30; i >= 0; i--) {
inverso *= inverso;
inverso %= mod;
if ((mod - 2) & (1 << i)) {
inverso *= x;
inverso %= mod;
}
}
}
long long int prod(int a, int b) {
if (a == 0 || b == 0) return 1LL;
long long int resp = 1LL;
for (int i = a; i > a - b; i--) {
resp *= i;
resp %= mod;
}
return resp;
}
int main() {
mp.clear();
calculaprimos();
int N, a;
long long int resp = 1LL;
scanf("%d", &N);
calculainverso(N - 1);
for (int i = 1; i <= N; i++) {
scanf("%d", &a);
fatora(a);
}
for (int i = 0; i <= cont; i++) {
if (v[i] > 0) {
resp *= prod(v[i] + N - 1, N - 1);
resp %= mod;
resp *= inverso;
resp %= mod;
}
}
if (N == 1)
printf("1\n");
else
printf("%I64d\n", resp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int maxn = 10013;
int Hash[maxn];
int save[maxn];
int sum[503][15003];
int C[16000][501];
int& pos(int n) {
int s = n % maxn;
while (Hash[s] && save[s] != n) s = (s + 1) % maxn;
save[s] = n;
return Hash[s];
}
void add(int n, int num) { pos(n) += num; }
void calC() {
C[0][0] = 1;
for (int i = 1; i < 16000; i++) {
for (int j = 0; j <= 500; j++) {
if (j == 0)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
}
int main() {
map<int, int> table;
map<int, int>::iterator it;
calC();
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
table[a]++;
}
for (it = table.begin(); it != table.end(); it++) {
int a = it->first;
int b = it->second;
for (int i = 2; i * i <= a; i++) {
int t = 0;
while (a % i == 0) {
a /= i;
t++;
}
add(i, t * b);
}
if (a != 1) add(a, b);
}
int res = 1;
for (int i = 0; i < maxn; i++)
if (Hash[i]) res = ((long long)res * C[n + Hash[i] - 1][n - 1]) % mod;
printf("%d\n", res);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.