text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int n, ans = 0, m, up[5005], dw[5005], pr[5005], nx[5005];
int upp[5005], dww[5005], prr[5005], nxx[5005];
char mp[5005][5005];
inline void initialize() {
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++) {
up[k * m + l] = upp[k * m + l];
dw[k * m + l] = dww[k * m + l];
nx[k * m + l] = nxx[k * m + l];
pr[k * m + l] = prr[k * m + l];
}
}
inline void del(int x) {
nx[pr[x]] = nx[x];
pr[nx[x]] = pr[x];
up[dw[x]] = up[x];
dw[up[x]] = dw[x];
}
int main() {
int t = 0, T = 0;
scanf("%d%d", &n, &m);
getchar();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%c", &mp[i][j]);
getchar();
}
memset(up, -1, sizeof(up));
memset(dw, -1, sizeof(dw));
memset(nx, -1, sizeof(nx));
memset(pr, -1, sizeof(pr));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mp[i][j] == '.') continue;
for (int k = i - 1; k >= 0; k--)
if (mp[k][j] != '.') {
up[i * m + j] = k * m + j;
break;
}
for (int k = i + 1; k < n; k++)
if (mp[k][j] != '.') {
dw[i * m + j] = k * m + j;
break;
}
for (int k = j + 1; k < m; k++)
if (mp[i][k] != '.') {
nx[i * m + j] = i * m + k;
break;
}
for (int k = j - 1; k >= 0; k--)
if (mp[i][k] != '.') {
pr[i * m + j] = i * m + k;
break;
}
}
}
for (int k = 0; k < n; k++)
for (int l = 0; l < m; l++) {
upp[k * m + l] = up[k * m + l];
dww[k * m + l] = dw[k * m + l];
nxx[k * m + l] = nx[k * m + l];
prr[k * m + l] = pr[k * m + l];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mp[i][j] == '.') continue;
int x = i, y = j, len = 1;
initialize();
del(i * m + j);
while (1) {
int k = x * m + y;
if (mp[x][y] == 'U' && up[k] >= 0)
x = up[k] / m;
else if (mp[x][y] == 'D' && dw[k] >= 0)
x = dw[k] / m;
else if (mp[x][y] == 'R' && nx[k] >= 0)
y = nx[k] % m;
else if (mp[x][y] == 'L' && pr[k] >= 0)
y = pr[k] % m;
else
break;
del(k);
len++;
}
if (len > ans)
ans = len, T = 1;
else if (len == ans)
T++;
}
}
printf("%d %d\n", ans, T);
return 0;
}
|
#include <bits/stdc++.h>
char s[5012];
int O[5012][4], list[5012][4];
int n, m;
int get(int x, int y) { return x * m + y; }
void Init(int a[][4]) {
int i, j, flag, now, p;
for (i = 0; i < m; i++) {
flag = 0;
for (j = 0; j < n; j++) {
p = get(j, i);
if (s[p] == -1) continue;
if (flag) {
a[p][0] = now;
} else {
a[p][0] = -1;
flag = 1;
}
now = p;
}
}
for (i = 0; i < m; i++) {
flag = 0;
for (j = n - 1; j >= 0; j--) {
p = get(j, i);
if (s[p] == -1) continue;
if (flag) {
a[p][2] = now;
} else {
a[p][2] = -1;
flag = 1;
}
now = p;
}
}
for (i = 0; i < n; i++) {
flag = 0;
for (j = m - 1; j >= 0; j--) {
p = get(i, j);
if (s[p] == -1) continue;
if (flag) {
a[p][1] = now;
} else {
a[p][1] = -1;
flag = 1;
}
now = p;
}
}
for (i = 0; i < n; i++) {
flag = 0;
for (j = 0; j < m; j++) {
p = get(i, j);
if (s[p] == -1) continue;
if (flag) {
a[p][3] = now;
} else {
a[p][3] = -1;
flag = 1;
}
now = p;
}
}
}
void del(int pos) {
int i;
for (i = 0; i < 4; i++)
if (list[pos][i] >= 0) list[list[pos][i]][i ^ 2] = list[pos][i ^ 2];
}
int count(int pos) {
int an = 1;
while (list[pos][s[pos]] >= 0) {
del(pos);
pos = list[pos][s[pos]];
an++;
}
return an;
}
int main() {
int ma = 0, an = 0, i, j, k, nm;
scanf("%d%d", &n, &m);
nm = n * m;
for (i = 0; i < n; i++) scanf("%s", s + i * m);
for (i = 0; i < nm; i++) {
if (s[i] == 'U')
s[i] = 0;
else if (s[i] == 'R')
s[i] = 1;
else if (s[i] == 'D')
s[i] = 2;
else if (s[i] == 'L')
s[i] = 3;
else if (s[i] == '.')
s[i] = -1;
}
Init(O);
for (i = 0; i < nm; i++) {
if (s[i] == -1) continue;
memcpy(list, O, sizeof(list));
int tmp = count(i);
if (tmp > ma) {
ma = tmp;
an = 1;
} else if (tmp == ma)
an++;
}
printf("%d %d\n", ma, an);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5000 + 5;
const string M = "URDL";
const int opos[] = {2, 3, 0, 1};
int n, m, cnt;
vector<char> mat[maxN];
struct node {
pair<int, int> a[4];
node() { a[0] = a[1] = a[2] = a[3] = pair<int, int>(-1, -1); }
};
vector<node> mov[maxN], asl[maxN];
inline void init() {
for (int i = 1; i <= n; i++) {
int past = -1;
for (int j = 1; j <= m; j++)
if (mat[i][j] != '.') {
if (past != -1) {
asl[i][past].a[1] = pair<int, int>(i, j);
asl[i][j].a[3] = pair<int, int>(i, past);
}
past = j;
}
}
for (int j = 1; j <= m; j++) {
int past = -1;
for (int i = 1; i <= n; i++)
if (mat[i][j] != '.') {
if (past != -1) {
asl[past][j].a[2] = pair<int, int>(i, j);
asl[i][j].a[0] = pair<int, int>(past, j);
}
past = i;
}
}
}
inline void SET() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mat[i][j] != '.') mov[i][j] = asl[i][j];
}
inline void go(int x, int y) {
if (x == -1) return;
cnt++;
pair<int, int> tmp;
for (int i = 0; i < 4; i++)
if ((tmp = mov[x][y].a[i]) != pair<int, int>(-1, -1)) {
mov[tmp.first][tmp.second].a[opos[i]] = mov[x][y].a[opos[i]];
}
int ind = M.find(mat[x][y]);
go(mov[x][y].a[ind].first, mov[x][y].a[ind].second);
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
mov[i].resize(m + 1);
mat[i].resize(m + 1);
asl[i].resize(m + 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> mat[i][j];
int maxi = -1, cmaxi = -1;
init();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mat[i][j] != '.') {
SET();
cnt = 0;
go(i, j);
(maxi == cnt) ? cmaxi++ : (maxi < cnt) ? maxi = cnt, cmaxi = 1 : true;
}
cout << maxi << ' ' << cmaxi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct no {
int u, d, l, r;
char dir;
};
no v[5000], O[5000];
int id[5000][5000];
char M[5000][5000];
int n, m;
void calcula(int x, int y) {
int a = id[x][y];
int resp = -1;
for (int i = x - 1; i >= 0; i--)
if (id[i][y] != -1) {
resp = id[i][y];
break;
}
O[a].u = resp;
resp = -1;
for (int i = x + 1; i < n; i++)
if (id[i][y] != -1) {
resp = id[i][y];
break;
}
O[a].d = resp;
resp = -1;
for (int i = y - 1; i >= 0; i--)
if (id[x][i] != -1) {
resp = id[x][i];
break;
}
O[a].l = resp;
resp = -1;
for (int i = y + 1; i < m; i++)
if (id[x][i] != -1) {
resp = id[x][i];
break;
}
O[a].r = resp;
}
int anda(int x) {
if (v[x].dir == 'U') return v[x].u;
if (v[x].dir == 'D') return v[x].d;
if (v[x].dir == 'L') return v[x].l;
if (v[x].dir == 'R') return v[x].r;
}
void apaga(int x) {
if (v[x].u != -1) v[v[x].u].d = v[x].d;
if (v[x].d != -1) v[v[x].d].u = v[x].u;
if (v[x].l != -1) v[v[x].l].r = v[x].r;
if (v[x].r != -1) v[v[x].r].l = v[x].l;
}
int main() {
scanf("%d %d", &n, &m);
memset(id, -1, sizeof id);
for (int i = 0; i < n; i++) scanf(" %s", M[i]);
int cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (M[i][j] != '.') id[i][j] = cnt++, O[cnt - 1].dir = M[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (id[i][j] != -1) calcula(i, j);
int ans = 0, qnts = 0;
for (int i = 0; i < cnt; i++) {
for (int j = 0; j < cnt; j++) v[j] = O[j];
int y = i;
int ret = 0;
while (1) {
int x = y;
y = anda(y);
if (y == -1) break;
apaga(x);
ret++;
}
if (ans < ret) {
qnts = 1;
ans = ret;
} else if (ans == ret) {
qnts++;
}
}
printf("%d %d\n", ans + 1, qnts);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<char> > g;
int n, m;
vector<vector<int> > nxtcol1, prvcol1, nxtrow1, prvrow1;
inline int solve(int r, int c) {
int ret = 0;
while (true) {
if (r >= n || c >= m) break;
ret++;
int i = r, j = c;
if (g[r][c] == 'L') {
c = prvcol1[r][j];
nxtcol1[r][c] = nxtcol1[r][j];
prvcol1[r][nxtcol1[r][j]] = c;
nxtrow1[prvrow1[r][j]][j] = nxtrow1[r][j];
prvrow1[nxtrow1[r][j]][j] = prvrow1[r][j];
} else if (g[r][c] == 'R') {
c = nxtcol1[r][j];
prvcol1[r][c] = prvcol1[r][j];
nxtcol1[r][prvcol1[r][j]] = c;
nxtrow1[prvrow1[r][j]][j] = nxtrow1[r][j];
prvrow1[nxtrow1[r][j]][j] = prvrow1[r][j];
} else if (g[r][c] == 'U') {
r = prvrow1[r][c];
nxtrow1[r][c] = nxtrow1[i][c];
prvrow1[nxtrow1[i][c]][c] = r;
nxtcol1[i][prvcol1[i][c]] = nxtcol1[i][c];
prvcol1[i][nxtcol1[i][c]] = prvcol1[i][c];
} else if (g[r][c] == 'D') {
r = nxtrow1[r][c];
prvrow1[r][c] = prvrow1[i][c];
nxtrow1[prvrow1[i][c]][c] = r;
nxtcol1[i][prvcol1[i][c]] = nxtcol1[i][c];
prvcol1[i][nxtcol1[i][c]] = prvcol1[i][c];
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
g.resize(n + 5);
vector<vector<int> > nxtcol(n + 5, vector<int>(m + 5));
vector<vector<int> > prvcol(n + 5, vector<int>(m + 5));
vector<vector<int> > nxtrow(n + 5, vector<int>(m + 5));
vector<vector<int> > prvrow(n + 5, vector<int>(m + 5));
for (int i = 0; i < n; i++) {
g[i].resize(m + 5);
for (int j = 0; j < m; j++) cin >> g[i][j];
}
for (int i = 0; i < n; i++) {
int last = m;
for (int j = m - 1; j >= 0; j--) {
if (g[i][j] != '.') {
nxtcol[i][j] = last;
prvcol[i][last] = j;
last = j;
}
}
prvcol[i][last] = m + 1;
}
for (int i = 0; i < m; i++) {
int last = n;
for (int j = n - 1; j >= 0; j--) {
if (g[j][i] != '.') {
nxtrow[j][i] = last;
prvrow[last][i] = j;
last = j;
}
}
prvrow[last][i] = n + 1;
}
int ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i][j] != '.') {
nxtcol1 = nxtcol;
prvcol1 = prvcol;
nxtrow1 = nxtrow;
prvrow1 = prvrow;
int temp = solve(i, j);
if (ans < temp)
ans = temp, cnt = 1;
else if (ans == temp)
cnt++;
}
}
}
cout << ans << " " << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5001;
char a[maxn][maxn];
int b[maxn][maxn], d[maxn];
int f[maxn][4], g[maxn][4];
int n, m, tot;
int solve(int k) {
int i, s = 0;
memcpy(g, f, sizeof(f));
i = k;
while (i) {
s++;
g[g[i][0]][1] = g[i][1];
g[g[i][1]][0] = g[i][0];
g[g[i][2]][3] = g[i][3];
g[g[i][3]][2] = g[i][2];
i = g[i][d[i]];
}
return s;
}
void init(int x, int y) {
int i, k = b[x][y];
for (i = x - 1; i >= 0; i--)
if (a[i][y] != '.') {
f[k][0] = b[i][y];
break;
}
for (i = x + 1; i < n; i++)
if (a[i][y] != '.') {
f[k][1] = b[i][y];
break;
}
for (i = y - 1; i >= 0; i--)
if (a[x][i] != '.') {
f[k][2] = b[x][i];
break;
}
for (i = y + 1; i < m; i++)
if (a[x][i] != '.') {
f[k][3] = b[x][i];
break;
}
}
int main() {
int i, j, k, s = 0, t = 1;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", a[i]);
for (j = 0; j < m; j++)
if (a[i][j] != '.') {
tot++;
b[i][j] = tot;
if (a[i][j] == 'U')
d[tot] = 0;
else if (a[i][j] == 'D')
d[tot] = 1;
else if (a[i][j] == 'L')
d[tot] = 2;
else if (a[i][j] == 'R')
d[tot] = 3;
}
}
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (a[i][j] != '.') init(i, j);
for (i = 1; i <= tot; i++) {
k = solve(i);
if (k > s) {
s = k;
t = 1;
} else if (k == s)
t++;
}
printf("%d %d\n", s, t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 10;
int n, m, ted[maxn], ans = 0;
string s[maxn];
vector<int> l[maxn], r[maxn], u[maxn], d[maxn];
void del(int i, int j) {
if (r[i][j] != m) l[i][r[i][j]] = l[i][j];
if (l[i][j] != -1) r[i][l[i][j]] = r[i][j];
if (u[i][j] != -1) d[u[i][j]][j] = d[i][j];
if (d[i][j] != n) u[d[i][j]][j] = u[i][j];
}
int f(int i, int j) {
int ret = 0;
if (s[i][j] == '.') return ret;
for (int i1 = 0; i1 < n; i1++)
for (int j1 = 0; j1 < m; j1++) {
l[i1][j1] = j1 - 1;
u[i1][j1] = i1 - 1;
r[i1][j1] = j1 + 1;
d[i1][j1] = i1 + 1;
}
for (int i1 = 0; i1 < n; i1++)
for (int j1 = 0; j1 < m; j1++)
if (s[i1][j1] == '.') del(i1, j1);
while (true) {
if (i == -1 || j == -1 || i == n || j == m) break;
del(i, j);
if (s[i][j] == 'L')
j = l[i][j];
else if (s[i][j] == 'U')
i = u[i][j];
else if (s[i][j] == 'R')
j = r[i][j];
else
i = d[i][j];
ret++;
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
l[i].resize(m);
r[i].resize(m);
u[i].resize(m);
d[i].resize(m);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int k = f(i, j);
ted[k]++;
ans = max(ans, k);
}
cout << ans << ' ' << ted[ans] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<long long, long long> ll;
typedef vector<long long> vl;
typedef vector<ll> vll;
typedef vector<vl> vvl;
template <typename T>
ostream &operator<<(ostream &o, vector<T> v) {
if (v.size() > 0) o << v[0];
for (unsigned i = 1; i < v.size(); i++) o << " " << v[i];
return o << "\n";
}
template <typename U, typename V>
ostream &operator<<(ostream &o, pair<U, V> p) {
return o << "(" << p.first << ", " << p.second << ") ";
}
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (unsigned i = 0; i < v.size(); i++) in >> v[i];
return in;
}
template <typename T>
istream &operator>>(istream &in, pair<T, T> &p) {
in >> p.first;
in >> p.second;
return in;
}
struct node {
long long l, r, d, u;
char v;
node(char value, long long _r, long long _d, long long _l, long long _u)
: l(_l), r(_r), d(_d), u(_u), v(value) {}
void print() {
cout << v << " ";
cout << "l"
<< "=" << l << " "
<< "r"
<< "=" << r << " "
<< "d"
<< "=" << d << " "
<< "u"
<< "=" << u << "\n";
;
}
};
vector<vector<node>> a;
long long n, m;
void del(long long x, long long y) {
a[x][a[x][y].l].r = a[x][y].r;
a[x][a[x][y].r].l = a[x][y].l;
a[a[x][y].d][y].u = a[x][y].u;
a[a[x][y].u][y].d = a[x][y].d;
}
void add(long long x, long long y) {
a[x][a[x][y].l].r = y;
a[x][a[x][y].r].l = y;
a[a[x][y].d][y].u = x;
a[a[x][y].u][y].d = x;
}
long long dfs(long long x, long long y) {
if (x == 0 or x == n + 1 or y == 0 or y == m + 1) return 0;
del(x, y);
long long res = 0;
long long i = x;
long long j = y;
if (a[i][j].v == 'U')
res = dfs(a[i][j].u, y);
else if (a[i][j].v == 'D')
res = dfs(a[i][j].d, y);
else if (a[i][j].v == 'R')
res = dfs(x, a[i][j].r);
else if (a[i][j].v == 'L')
res = dfs(x, a[i][j].l);
add(x, y);
return res + 1;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(20);
cin >> n >> m;
a.resize(n + 2, vector<node>(m + 2, node('X', m, n, 0, 0)));
for (long long i = (1); i < (long long)n + 1; i++)
for (long long j = (1); j < (long long)m + 1; j++) cin >> a[i][j].v;
for (long long i = (1); i < (long long)n + 1; i++) {
long long p = 0;
for (long long(j) = 1; (j) < (m + 2); (j)++) {
if (a[i][j].v != '.') {
a[i][j].l = p;
a[i][p].r = j;
p = j;
}
}
}
for (long long i = (1); i < (long long)m + 1; i++) {
long long p = 0;
for (long long(j) = 1; (j) < (n + 2); (j)++) {
if (a[j][i].v != '.') {
a[j][i].u = p;
a[p][i].d = j;
p = j;
}
}
}
long long ans = 0;
long long cnt = 0;
for (long long i = (1); i < (long long)n + 1; i++)
for (long long j = (1); j < (long long)m + 1; j++)
if (a[i][j].v != '.') {
long long x = dfs(i, j);
if (x > ans)
ans = x, cnt = 1;
else if (x == ans)
cnt++;
}
cout << ans << " " << cnt << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[5005][5005];
vector<int> up[5005], dn[5005], lt[5005], rt[5005];
void del(int x, int y) {
dn[up[x][y]][y] = dn[x][y];
up[dn[x][y]][y] = up[x][y];
rt[x][lt[x][y]] = rt[x][y];
lt[x][rt[x][y]] = lt[x][y];
}
void ins(int x, int y) {
dn[up[x][y]][y] = x;
up[dn[x][y]][y] = x;
rt[x][lt[x][y]] = y;
lt[x][rt[x][y]] = y;
}
int dfs(int x, int y) {
int ans = 1;
if (s[x][y] == 'U') {
int cur = up[x][y];
if (cur) del(x, y), ans += dfs(cur, y), ins(x, y);
} else if (s[x][y] == 'D') {
int cur = dn[x][y];
if (cur != n + 1) del(x, y), ans += dfs(cur, y), ins(x, y);
} else if (s[x][y] == 'L') {
int cur = lt[x][y];
if (cur) del(x, y), ans += dfs(x, cur), ins(x, y);
} else if (s[x][y] == 'R') {
int cur = rt[x][y];
if (cur != m + 1) del(x, y), ans += dfs(x, cur), ins(x, y);
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 0; i <= n + 1; i++)
up[i].resize(m + 3), dn[i].resize(m + 3), lt[i].resize(m + 3),
rt[i].resize(m + 3);
for (int i = 1; i <= n; i++) {
int pre = 0;
for (int j = 1; j <= m; j++)
if (s[i][j] != '.') rt[i][pre] = j, lt[i][j] = pre, pre = j;
rt[i][pre] = m + 1;
lt[i][m + 1] = pre;
}
for (int j = 1; j <= m; j++) {
int pre = 0;
for (int i = 1; i <= n; i++)
if (s[i][j] != '.') dn[pre][j] = i, up[i][j] = pre, pre = i;
dn[pre][j] = n + 1;
up[n + 1][j] = pre;
}
int ans = 0, mx = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] != '.') {
int cur = dfs(i, j);
if (cur > mx)
mx = cur, ans = 1;
else if (cur == mx)
ans++;
}
printf("%d %d\n", mx, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, y, z, now, ans, dp[5005], l[5005], r[5005], u[5005], d[5005],
lh[5005], rh[5005], uh[5005], dh[5005];
char a[5005], c;
void dsu(long long x) {
if (a[x] == 'U' && !uh[x]) {
return;
}
if (a[x] == 'D' && !dh[x]) {
return;
}
if (a[x] == 'R' && !rh[x]) {
return;
}
if (a[x] == 'L' && !lh[x]) {
return;
}
ans++;
y = lh[x], z = rh[x];
rh[y] = z, lh[z] = y;
y = uh[x], z = dh[x];
dh[y] = z, uh[z] = y;
if (a[x] == 'U') {
dsu(uh[x]);
} else if (a[x] == 'R') {
dsu(rh[x]);
} else if (a[x] == 'L') {
dsu(lh[x]);
} else if (a[x] == 'D') {
dsu(dh[x]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c;
a[(i - 1) * m + j] = c;
}
}
for (int i = 1; i <= m; i++) {
now = 0;
for (int j = 1; j <= n; j++) {
if (a[(j - 1) * m + i] == '.') {
continue;
}
d[now] = (j - 1) * m + i;
u[(j - 1) * m + i] = now;
now = (j - 1) * m + i;
}
d[now] = 0;
}
for (int i = 1; i <= n; i++) {
now = 0;
for (int j = 1; j <= m; j++) {
if (a[(i - 1) * m + j] == '.') {
continue;
}
r[now] = (i - 1) * m + j;
l[(i - 1) * m + j] = now;
now = (i - 1) * m + j;
}
r[now] = 0;
}
for (int i = 1; i <= n; i++) {
for (int q = 1; q <= m; q++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
lh[(j - 1) * m + k] = l[(j - 1) * m + k];
rh[(j - 1) * m + k] = r[(j - 1) * m + k];
uh[(j - 1) * m + k] = u[(j - 1) * m + k];
dh[(j - 1) * m + k] = d[(j - 1) * m + k];
}
}
ans = 1;
if (a[(i - 1) * m + q] != '.') {
dsu((i - 1) * m + q);
dp[ans]++;
}
}
}
for (int i = 5000; i >= 1; i--) {
if (dp[i]) {
cout << i << " " << dp[i] << '\n';
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<string> grid;
bool **vis;
pair<int, int> **nxtUP, **nxtDown, **nxtRight, **nxtLeft;
const int N = 5005;
void init() {
vis = new bool *[n + 1];
for (int i = 0; i <= n; i++) vis[i] = new bool[m + 1];
nxtUP = new pair<int, int> *[n + 1];
for (int i = 0; i <= n; i++) nxtUP[i] = new pair<int, int>[m + 1];
nxtDown = new pair<int, int> *[n + 1];
for (int i = 0; i <= n; i++) nxtDown[i] = new pair<int, int>[m + 1];
nxtRight = new pair<int, int> *[n + 1];
for (int i = 0; i <= n; i++) nxtRight[i] = new pair<int, int>[m + 1];
nxtLeft = new pair<int, int> *[n + 1];
for (int i = 0; i <= n; i++) nxtLeft[i] = new pair<int, int>[m + 1];
}
void clear() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
vis[i][j] = false;
nxtRight[i][j] = nxtLeft[i][j] = nxtUP[i][j] = nxtDown[i][j] = {i, j};
}
}
}
pair<int, int> get_nxt_up(int i, int j) {
pair<int, int> nxt = nxtUP[i][j];
nxt.first--;
if (nxt.first <= -1 || nxt.second <= -1) return {-1, -1};
if (nxt.first >= n || nxt.second >= m) return {n, m};
if (!vis[nxt.first][nxt.second] && grid[nxt.first][nxt.second] != '.')
return nxtUP[i][j] = nxt;
return nxtUP[i][j] = get_nxt_up(nxt.first, nxt.second);
}
pair<int, int> get_nxt_down(int i, int j) {
pair<int, int> nxt = nxtDown[i][j];
nxt.first++;
if (nxt.first <= -1 || nxt.second <= -1) return {-1, -1};
if (nxt.first >= n || nxt.second >= m) return {n, m};
if (!vis[nxt.first][nxt.second] && grid[nxt.first][nxt.second] != '.')
return nxtDown[i][j] = nxt;
return nxtDown[i][j] = get_nxt_down(nxt.first, nxt.second);
}
pair<int, int> get_nxt_right(int i, int j) {
pair<int, int> nxt = nxtRight[i][j];
nxt.second++;
if (nxt.first <= -1 || nxt.second <= -1) return {-1, -1};
if (nxt.first >= n || nxt.second >= m) return {n, m};
if (!vis[nxt.first][nxt.second] && grid[nxt.first][nxt.second] != '.')
return nxtRight[i][j] = nxt;
return nxtRight[i][j] = get_nxt_right(nxt.first, nxt.second);
}
pair<int, int> get_nxt_left(int i, int j) {
pair<int, int> nxt = nxtLeft[i][j];
nxt.second--;
if (nxt.first <= -1 || nxt.second <= -1) return {-1, -1};
if (nxt.first >= n || nxt.second >= m) return {n, m};
if (!vis[nxt.first][nxt.second] && grid[nxt.first][nxt.second] != '.')
return nxtLeft[i][j] = nxt;
return nxtLeft[i][j] = get_nxt_left(nxt.first, nxt.second);
}
int solve(int i, int j) {
int ret = 0;
while (true) {
if (i == n || j == m || i == -1 || j == -1) break;
ret++;
vis[i][j] = true;
pair<int, int> nxt;
if (grid[i][j] == 'U') nxt = get_nxt_up(i, j);
if (grid[i][j] == 'D') nxt = get_nxt_down(i, j);
if (grid[i][j] == 'R') nxt = get_nxt_right(i, j);
if (grid[i][j] == 'L') nxt = get_nxt_left(i, j);
i = nxt.first;
j = nxt.second;
}
return ret;
}
int freq[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
init();
for (int i = 0; i < n; i++) {
string x;
cin >> x;
grid.push_back(x);
}
int mx = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '.') continue;
clear();
int curr = solve(i, j);
freq[curr]++;
mx = max(mx, curr);
}
}
cout << mx << ' ' << freq[mx];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[5001][5001];
int p[5001][5001];
int a[5001][4], A[5001][4];
int d[5001];
int dis, num;
int main() {
int nn = 0;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] != '.') {
p[i][j] = ++nn;
if (s[i][j] == 'U') d[nn] = 0;
if (s[i][j] == 'D') d[nn] = 1;
if (s[i][j] == 'L') d[nn] = 2;
if (s[i][j] == 'R') d[nn] = 3;
} else
p[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (p[i][j]) {
for (int k = i - 1; k >= 0; k--) {
if (p[k][j]) {
a[p[i][j]][0] = p[k][j];
break;
}
}
for (int k = i + 1; k < n; k++) {
if (p[k][j]) {
a[p[i][j]][1] = p[k][j];
break;
}
}
for (int k = j - 1; k >= 0; k--) {
if (p[i][k]) {
a[p[i][j]][2] = p[i][k];
break;
}
}
for (int k = j + 1; k < m; k++) {
if (p[i][k]) {
a[p[i][j]][3] = p[i][k];
break;
}
}
}
}
}
dis = 0;
num = 0;
for (int i = 1; i <= nn; i++) {
memcpy(A, a, sizeof(a));
int j = i;
int length = 0;
while (j) {
length++;
A[A[j][0]][1] = A[j][1];
A[A[j][1]][0] = A[j][0];
A[A[j][2]][3] = A[j][3];
A[A[j][3]][2] = A[j][2];
j = A[j][d[j]];
}
if (dis < length) {
dis = length;
num = 1;
} else if (dis == length)
num++;
}
printf("%d %d\n", dis, num);
return 0;
}
|
#include <bits/stdc++.h>
int n, m, ans;
int L[10010], R[10010], U[10010], D[10010], col[10010], sum[10010], row[10010];
char s[5010][5010];
int node;
void build(int n, int m) {
int head = 0;
L[0] = m;
R[0] = 1;
for (int i = 1; i <= m; i++) {
L[i] = i - 1;
R[i] = (i + 1) % (m + 1);
col[i] = U[i] = D[i] = i;
sum[i] = 0;
}
node = m;
for (int i = 1; i <= n; i++) {
int head = 0;
for (int j = 1; j <= m; j++) {
if (s[i][j] == '.') continue;
node++;
D[U[j]] = node;
U[node] = U[j];
D[node] = j;
U[j] = node;
if (!head) {
head = node;
L[head] = R[head] = head;
} else {
L[node] = L[head];
R[node] = head;
R[L[node]] = node;
L[head] = node;
}
col[node] = j;
row[node] = i;
sum[j]++;
}
}
}
void remove(int node) {
L[R[node]] = L[node];
R[L[node]] = R[node];
U[D[node]] = U[node];
D[U[node]] = D[node];
}
void resume(int node) {
U[D[node]] = node;
D[U[node]] = node;
L[R[node]] = node;
R[L[node]] = node;
}
void dfs(int id) {
ans++;
int x = row[id];
int y = col[id];
if (y == 0) {
x--;
y = m;
}
if (s[x][y] == 'D') {
if (D[id] > id) {
remove(id);
dfs(D[id]);
resume(id);
}
} else if (s[x][y] == 'U') {
if (U[id] < id && U[id] > m) {
remove(id);
dfs(U[id]);
resume(id);
}
} else if (s[x][y] == 'L') {
if (L[id] < id) {
remove(id);
dfs(L[id]);
resume(id);
}
} else {
if (R[id] > id) {
remove(id);
dfs(R[id]);
resume(id);
}
}
}
int test(int id) {
ans = 0;
dfs(id);
return ans;
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
build(n, m);
int maxx = 0, num = 1;
for (int ii = m + 1; ii <= node; ii++) {
int ans = test(ii);
if (ans > maxx) {
maxx = ans;
num = 1;
} else if (ans == maxx)
num++;
}
printf("%d %d\n", maxx, num);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5;
int n, m, mx, c, kam;
vector<vector<char> > a, tmp;
vector<vector<int> > up, down, l, r, tmpu, tmpd, tmpl, tmpr;
void cpy() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
tmp[i][j] = a[i][j];
tmpu[i][j] = up[i][j];
tmpd[i][j] = down[i][j];
tmpl[i][j] = l[i][j];
tmpr[i][j] = r[i][j];
}
}
}
bool valid(int x) { return x != n + m; }
void solve(int i, int j) {
int c = 0;
while (i != n + m && j != n + m) {
c++;
if (valid(tmpu[i][j])) tmpd[tmpu[i][j]][j] = tmpd[i][j];
if (valid(tmpd[i][j])) tmpu[tmpd[i][j]][j] = tmpu[i][j];
if (valid(tmpl[i][j])) tmpr[i][tmpl[i][j]] = tmpr[i][j];
if (valid(tmpr[i][j])) tmpl[i][tmpr[i][j]] = tmpl[i][j];
if (tmp[i][j] == 'U') {
i = tmpu[i][j];
} else if (tmp[i][j] == 'D') {
i = tmpd[i][j];
} else if (tmp[i][j] == 'L') {
j = tmpl[i][j];
} else {
j = tmpr[i][j];
}
}
if (c == mx)
kam++;
else if (c > mx) {
mx = c;
kam = 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
up = down = r = l = tmpl = tmpr = tmpu = tmpd =
vector<vector<int> >(n + 5, vector<int>(m + 5));
a = tmp = vector<vector<char> >(n + 5, vector<char>(m + 5));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
up[i][j] = down[i][j] = l[i][j] = r[i][j] = n + m;
if (a[i][j] != '.') {
int x = i - 1;
while (x >= 0 && a[x][j] == '.') x--;
if (x >= 0) up[i][j] = x;
x = i + 1;
while (x < n && a[x][j] == '.') x++;
if (x < n) down[i][j] = x;
x = j - 1;
while (x >= 0 && a[i][x] == '.') x--;
if (x >= 0) l[i][j] = x;
x = j + 1;
while (x < m && a[i][x] == '.') x++;
if (x < m) r[i][j] = x;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '.') continue;
cpy();
solve(i, j);
}
}
cout << mx << ' ' << kam << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> f;
int N, M;
int visited[5002];
int jump_left[5002];
int jump_right[5002];
int jump_up[5002];
int jump_down[5002];
int get_jump_up(int i, int j) { return jump_up[i * M + j]; }
void set_jump_up(int i, int j, int value) { jump_up[i * M + j] = value; }
int get_jump_down(int i, int j) { return jump_down[i * M + j]; }
void set_jump_down(int i, int j, int value) { jump_down[i * M + j] = value; }
int get_jump_right(int i, int j) { return jump_right[i * M + j]; }
void set_jump_right(int i, int j, int value) { jump_right[i * M + j] = value; }
int get_jump_left(int i, int j) { return jump_left[i * M + j]; }
void set_jump_left(int i, int j, int value) { jump_left[i * M + j] = value; }
int get_visited(int i, int j) { return visited[i * M + j]; }
void set_visited(int i, int j, int value) { visited[i * M + j] = value; }
int get_next_right(int i_curr, int j_curr) {
int j_next = j_curr + max(get_jump_right(i_curr, j_curr), 1);
if (j_next >= M) {
set_jump_right(i_curr, j_curr, j_next - j_curr);
return j_next;
}
if (f[i_curr][j_next] == '.' || get_visited(i_curr, j_next)) {
int res = get_next_right(i_curr, j_next);
set_jump_right(i_curr, j_curr, res - j_curr);
return res;
}
return j_next;
}
int get_next_left(int i_curr, int j_curr) {
int j_next = j_curr - max(get_jump_left(i_curr, j_curr), 1);
if (j_next < 0) {
set_jump_left(i_curr, j_curr, j_next - j_curr);
return j_next;
}
if (f[i_curr][j_next] == '.' || get_visited(i_curr, j_next)) {
int res = get_next_left(i_curr, j_next);
set_jump_left(i_curr, j_curr, j_curr - res);
return res;
}
return j_next;
}
int main(int argc, char* argv[]) {
string str;
getline(cin, str);
sscanf(str.c_str(), "%d %d", &N, &M);
for (int i = 0; i < (int)(N); ++i) {
getline(cin, str);
f.push_back(str);
}
int N = f.size();
int M = f[0].size();
int max_path = 0;
int max_path_count = 1;
for (int i = 0; i < (int)(N); ++i) {
for (int j = 0; j < (int)(M); ++j) {
if (f[i][j] == '.') continue;
memset(visited, 0, sizeof(visited));
memset(jump_left, 0, sizeof(jump_left));
memset(jump_right, 0, sizeof(jump_right));
memset(jump_up, 0, sizeof(jump_up));
memset(jump_down, 0, sizeof(jump_down));
int i_curr = i, j_curr = j;
int path = 1;
while (true) {
set_visited(i_curr, j_curr, true);
if (f[i_curr][j_curr] == 'U') {
int k = i_curr - max(get_jump_up(i_curr, j_curr), 1);
while (k >= 0 && (f[k][j_curr] == '.' || get_visited(k, j_curr))) {
k -= max(get_jump_up(k, j_curr), 1);
}
set_jump_up(i_curr, j_curr, i_curr - k);
if (k >= 0) {
path++;
i_curr = k;
} else
break;
} else if (f[i_curr][j_curr] == 'D') {
int k = i_curr + max(get_jump_down(i_curr, j_curr), 1);
while (k < N && (f[k][j_curr] == '.' || get_visited(k, j_curr))) {
k += max(get_jump_down(k, j_curr), 1);
}
set_jump_down(i_curr, j_curr, k - i_curr);
if (k < N) {
path++;
i_curr = k;
} else
break;
} else if (f[i_curr][j_curr] == 'L') {
int k = get_next_left(i_curr, j_curr);
if (k >= 0) {
path++;
j_curr = k;
} else
break;
} else if (f[i_curr][j_curr] == 'R') {
int k = get_next_right(i_curr, j_curr);
if (k < M) {
path++;
j_curr = k;
} else
break;
}
}
if (path > max_path) {
max_path = path;
max_path_count = 1;
} else if (path == max_path) {
max_path_count++;
}
}
}
cout << max_path << " " << max_path_count << "\n";
int temp;
std::cin >> temp;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
char s[N];
char mp[N];
int up[N], down[N], leftt[N], rightt[N];
int u[N], d[N], l[N], r[N];
int sum;
int tot;
int n, m, nm;
void bfs(int t) {
while (1) {
sum++;
int x = t;
int tmp = x % m;
if (tmp == 0) tmp = m;
int liml = x - tmp + 1, limr = liml + m - 1;
if (mp[t] == 'L') {
x = leftt[x];
if (x == 0) break;
} else if (mp[t] == 'R') {
x = rightt[x];
if (x == 0) break;
} else if (mp[t] == 'U') {
x = up[x];
if (x == 0) break;
} else if (mp[t] == 'D') {
x = down[x];
if (x == 0) break;
}
if (leftt[t] != 0) rightt[leftt[t]] = rightt[t];
if (rightt[t] != 0) leftt[rightt[t]] = leftt[t];
if (up[t] != 0) down[up[t]] = down[t];
if (down[t] != 0) up[down[t]] = up[t];
t = x;
}
}
void finds(int x) {
int tmp = x % m;
if (tmp == 0) tmp = m;
int liml = x - tmp + 1, limr = liml + m - 1;
int t = x - m;
while (t > 0 && mp[t] == '.') t -= m;
if (t <= 0) t = 0;
up[x] = t;
t = x + m;
while (t <= nm && mp[t] == '.') t += m;
if (t > nm) t = 0;
down[x] = t;
t = x - 1;
while (t >= liml && mp[t] == '.') t--;
if (t < liml) t = 0;
leftt[x] = t;
t = x + 1;
while (t <= limr && mp[t] == '.') t++;
if (t > limr) t = 0;
rightt[x] = t;
u[x] = up[x];
d[x] = down[x];
l[x] = leftt[x];
r[x] = rightt[x];
}
void clean() {
for (int i = 1; i <= nm; i++)
leftt[i] = l[i], rightt[i] = r[i], up[i] = u[i], down[i] = d[i];
}
int main() {
scanf("%d%d", &n, &m);
nm = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) mp[++nm] = s[j];
}
for (int i = 1; i <= nm; i++) finds(i);
int ans = 0, t = 0;
for (int i = 1; i <= nm; i++)
if (mp[i] != '.') {
sum = 0;
clean();
bfs(i);
if (sum > ans) {
ans = sum;
t = 1;
} else if (sum == ans)
t++;
}
printf("%d %d\n", ans, t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct chip {
int l;
int r;
int u;
int d;
};
vector<char> a[5005];
vector<chip> link1[5005], link2[5005];
int n, m, kq, res;
void nhap() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
char x;
for (int i = 1; i <= n; ++i) a[i].push_back(' ');
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
cin >> x;
a[i].push_back(x);
}
for (int i = 1; i <= n; ++i) a[i].push_back(' ');
for (int i = 0; i <= m + 1; ++i) {
a[0].push_back(' ');
a[n + 1].push_back(' ');
}
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= m + 1; ++j) {
chip x;
x.l = 0;
x.r = 0;
x.u = 0;
x.d = 0;
link1[i].push_back(x);
link2[i].push_back(x);
}
}
void prep() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] != '.') {
int l = j - 1, r = j + 1, u = i - 1, d = i + 1;
while (a[i][l] == '.' && l > 0) --l;
while (a[i][r] == '.' && r <= m) ++r;
while (a[u][j] == '.' && u > 0) --u;
while (a[d][j] == '.' && d <= n) ++d;
link1[i][j].l = l;
link1[i][j].r = r;
link1[i][j].u = u;
link1[i][j].d = d;
}
}
void xl(int x, int y) {
int dem = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) link2[i][j] = link1[i][j];
while (a[x][y] != '.' && x > 0 && x <= n && y > 0 && y <= m) {
++dem;
int l = link2[x][y].l, r = link2[x][y].r, u = link2[x][y].u,
d = link2[x][y].d;
link2[x][l].r = r;
link2[x][r].l = l;
link2[u][y].d = d;
link2[d][y].u = u;
if (a[x][y] == 'L')
y = l;
else if (a[x][y] == 'R')
y = r;
else if (a[x][y] == 'U')
x = u;
else if (a[x][y] == 'D')
x = d;
}
kq = max(kq, dem);
}
void xl1(int x, int y) {
int dem = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) link2[i][j] = link1[i][j];
while (a[x][y] != '.' && x > 0 && x <= n && y > 0 && y <= m) {
++dem;
int l = link2[x][y].l, r = link2[x][y].r, u = link2[x][y].u,
d = link2[x][y].d;
link2[x][l].r = r;
link2[x][r].l = l;
link2[u][y].d = d;
link2[d][y].u = u;
if (a[x][y] == 'L')
y = l;
else if (a[x][y] == 'R')
y = r;
else if (a[x][y] == 'U')
x = u;
else if (a[x][y] == 'D')
x = d;
}
if (dem == kq) ++res;
}
int main() {
nhap();
prep();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] != '.') xl(i, j);
cout << kq << ' ';
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] != '.') xl1(i, j);
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int maxn = 5003;
int n, m;
vector<char> t[maxn];
void read() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
t[i].resize(m + 3);
for (int j = 1; j <= m; j++) cin >> t[i][j];
}
}
vector<int> nxt_u[maxn], nxt_d[maxn], nxt_l[maxn], nxt_r[maxn];
void solve() {
for (int i = 0; i <= n + 1; i++) {
nxt_u[i].resize(m + 3);
nxt_d[i].resize(m + 3);
nxt_l[i].resize(m + 3);
nxt_r[i].resize(m + 3);
}
int ans = 0, cnt_ans = 0;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= m; y++)
if (t[x][y] != '.') {
for (int j = 1; j <= m; j++) nxt_u[1][j] = 0, nxt_d[n][j] = n + 1;
for (int i = 1; i <= n; i++) nxt_l[i][1] = 0, nxt_r[i][m] = m + 1;
for (int i = 2; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (t[i - 1][j] == '.')
nxt_u[i][j] = nxt_u[i - 1][j];
else
nxt_u[i][j] = i - 1;
}
for (int i = n - 1; i >= 1; i--)
for (int j = 1; j <= m; j++) {
if (t[i + 1][j] == '.')
nxt_d[i][j] = nxt_d[i + 1][j];
else
nxt_d[i][j] = i + 1;
}
for (int j = 2; j <= m; j++)
for (int i = 1; i <= n; i++) {
if (t[i][j - 1] == '.')
nxt_l[i][j] = nxt_l[i][j - 1];
else
nxt_l[i][j] = j - 1;
}
for (int j = m - 1; j >= 1; j--)
for (int i = 1; i <= n; i++) {
if (t[i][j + 1] == '.')
nxt_r[i][j] = nxt_r[i][j + 1];
else
nxt_r[i][j] = j + 1;
}
int cnt = 0;
int curr_x = x, curr_y = y;
while (curr_x >= 1 && curr_x <= n && curr_y >= 1 && curr_y <= m) {
cnt++;
nxt_r[curr_x][nxt_l[curr_x][curr_y]] = nxt_r[curr_x][curr_y];
nxt_l[curr_x][nxt_r[curr_x][curr_y]] = nxt_l[curr_x][curr_y];
nxt_u[nxt_d[curr_x][curr_y]][curr_y] = nxt_u[curr_x][curr_y];
nxt_d[nxt_u[curr_x][curr_y]][curr_y] = nxt_d[curr_x][curr_y];
if (t[curr_x][curr_y] == 'R')
curr_y = nxt_r[curr_x][curr_y];
else if (t[curr_x][curr_y] == 'U')
curr_x = nxt_u[curr_x][curr_y];
else if (t[curr_x][curr_y] == 'D')
curr_x = nxt_d[curr_x][curr_y];
else
curr_y = nxt_l[curr_x][curr_y];
}
if (cnt > ans) ans = cnt, cnt_ans = 0;
if (cnt == ans) cnt_ans++;
}
cout << ans << " " << cnt_ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5000;
string s[5001];
int n, m, ans, t;
int **l, **r, **u, **d;
void build() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (!i)
u[i][j] = -1;
else {
u[i][j] = u[i - 1][j];
if (s[i - 1][j] != '.') u[i][j] = i - 1;
}
if (!j)
l[i][j] = -1;
else {
l[i][j] = l[i][j - 1];
if (s[i][j - 1] != '.') l[i][j] = j - 1;
}
}
for (int i = n - 1; i + 1; i--)
for (int j = m - 1; j + 1; j--) {
if (!(n - i - 1))
d[i][j] = -1;
else {
d[i][j] = d[i + 1][j];
if (s[i + 1][j] != '.') d[i][j] = i + 1;
}
if (!(m - j - 1))
r[i][j] = -1;
else {
r[i][j] = r[i][j + 1];
if (s[i][j + 1] != '.') r[i][j] = j + 1;
}
}
}
void upd(int y, int x) {
if (r[y][x] >= 0) l[y][r[y][x]] = l[y][x];
if (l[y][x] >= 0) r[y][l[y][x]] = r[y][x];
if (d[y][x] >= 0) u[d[y][x]][x] = u[y][x];
if (u[y][x] >= 0) d[u[y][x]][x] = d[y][x];
}
int go(int y, int x) {
if (min(x, y) < 0) return 0;
char c = s[y][x];
upd(y, x);
if (c == 'L') return go(y, l[y][x]) + 1;
if (c == 'R') return go(y, r[y][x]) + 1;
if (c == 'U') return go(u[y][x], x) + 1;
return go(d[y][x], x) + 1;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
l = new int *[n + 10];
r = new int *[n + 10];
u = new int *[n + 10];
d = new int *[n + 10];
for (int i = 0; i < n + 10; i++) {
l[i] = new int[m + 10];
r[i] = new int[m + 10];
d[i] = new int[m + 10];
u[i] = new int[m + 10];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] != '.') {
build();
int kk = go(i, j);
if (kk > ans) {
t = 0;
ans = kk;
}
if (kk == ans) t++;
}
cout << ans << " " << t << endl;
cin >> n;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
char A[6000][6000];
vector<int> U[6000];
vector<int> D[6000];
vector<int> R[6000];
vector<int> L[6000];
int hv[6000][6000];
int mx, cnt;
int process(int sx, int sy) {
for (int Ni = 0; Ni < N; Ni++) {
U[Ni].clear();
D[Ni].clear();
R[Ni].clear();
L[Ni].clear();
for (int Mi = 0; Mi < M; Mi++) {
if (A[Ni][Mi] != '.')
hv[Ni][Mi] = true;
else
hv[Ni][Mi] = false;
U[Ni].push_back(Ni - 1), D[Ni].push_back(Ni + 1);
R[Ni].push_back(Mi + 1), L[Ni].push_back(Mi - 1);
}
}
int _cnt = 0;
int nx = sx, ny = sy;
while (0 <= nx && nx < N && 0 <= ny && ny < M) {
_cnt++;
hv[nx][ny] = false;
if (A[nx][ny] == 'U') {
int px = nx, py = ny;
while (0 <= px && px < N && !hv[px][py]) px = U[px][py];
U[nx][ny] = px;
nx = px;
} else if (A[nx][ny] == 'D') {
int px = nx, py = ny;
while (0 <= px && px < N && !hv[px][py]) px = D[px][py];
D[nx][ny] = px;
nx = px;
} else if (A[nx][ny] == 'R') {
int px = nx, py = ny;
while (0 <= py && py < M && !hv[px][py]) py = R[px][py];
R[nx][ny] = py;
ny = py;
} else if (A[nx][ny] == 'L') {
int px = nx, py = ny;
while (0 <= py && py < M && !hv[px][py]) py = L[px][py];
L[nx][ny] = py;
ny = py;
}
}
return _cnt;
}
int main() {
scanf("%d %d", &N, &M);
for (int Ni = 0; Ni < N; Ni++) scanf("%s", A[Ni]);
for (int Ni = 0; Ni < N; Ni++)
for (int Mi = 0; Mi < M; Mi++) {
if (A[Ni][Mi] != '.') {
int p = process(Ni, Mi);
if (p > mx)
mx = p, cnt = 1;
else if (p == mx)
cnt++;
}
}
printf("%d %d\n", mx, cnt);
}
|
#include <bits/stdc++.h>
int n, m, i, j, eid, cur, e, l[5006], r[5006], u[5006], d[5006], L[5006],
R[5006], D[5006], U[5006], c, res, rc;
short id[5006][5006];
char s[5006][5006], t[5006];
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", s[i]);
for (i = eid = 0; i < n; i++)
for (j = 0; j < m; j++)
if (s[i][j] != '.') {
id[i][j] = ++eid;
t[eid] = s[i][j];
}
for (i = 0; i < n; i++) {
for (j = e = 0; j < m; j++)
if (s[i][j] != '.') {
L[id[i][j]] = e;
e = id[i][j];
}
e = 0;
for (j = m - 1; j >= 0; j--)
if (s[i][j] != '.') {
R[id[i][j]] = e;
e = id[i][j];
}
}
for (j = 0; j < m; j++) {
for (i = e = 0; i < n; i++)
if (s[i][j] != '.') {
U[id[i][j]] = e;
e = id[i][j];
}
e = 0;
for (i = n - 1; i >= 0; i--)
if (s[i][j] != '.') {
D[id[i][j]] = e;
e = id[i][j];
}
}
for (e = 1; e <= eid; e++) {
for (i = 1; i <= eid; i++) {
l[i] = L[i];
r[i] = R[i];
u[i] = U[i];
d[i] = D[i];
}
for (c = 0, cur = e; cur != 0; ++c, cur = j) {
if (t[cur] == 'L') j = l[cur];
if (t[cur] == 'R') j = r[cur];
if (t[cur] == 'U') j = u[cur];
if (t[cur] == 'D') j = d[cur];
if (l[cur] != 0) r[l[cur]] = r[cur];
if (r[cur] != 0) l[r[cur]] = l[cur];
if (u[cur] != 0) d[u[cur]] = d[cur];
if (d[cur] != 0) u[d[cur]] = u[cur];
}
if (c > res) {
res = c;
rc = 0;
}
if (c == res) rc++;
}
printf("%d %d\n", res, rc);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct item {
char c;
item *l, *r, *u, *d;
};
item make_item(char c) {
item it;
it.l = NULL;
it.r = NULL;
it.u = NULL;
it.d = NULL;
it.c = c;
return it;
}
int n, m;
vector<vector<item> > B;
void build_net_of_links() {
for (int i = 1; i <= n; i++) {
item *it = NULL;
for (int j = 1; j <= m; j++) {
B[i][j].l = it;
if (B[i][j].c != '.') it = &B[i][j];
}
}
for (int i = 1; i <= n; i++) {
item *it = NULL;
for (int j = m; j >= 1; j--) {
B[i][j].r = it;
if (B[i][j].c != '.') it = &B[i][j];
}
}
for (int j = 1; j <= m; j++) {
item *it = NULL;
for (int i = 1; i <= n; i++) {
B[i][j].u = it;
if (B[i][j].c != '.') it = &B[i][j];
}
}
for (int j = 1; j <= m; j++) {
item *it = NULL;
for (int i = n; i >= 1; i--) {
B[i][j].d = it;
if (B[i][j].c != '.') it = &B[i][j];
}
}
}
int modeling(int is, int js) {
build_net_of_links();
item *cur = &B[is][js];
int res = 0;
while (cur) {
if (cur->l) cur->l->r = cur->r;
if (cur->r) cur->r->l = cur->l;
if (cur->u) cur->u->d = cur->d;
if (cur->d) cur->d->u = cur->u;
if (cur->c == 'L')
cur = cur->l;
else if (cur->c == 'R')
cur = cur->r;
else if (cur->c == 'D')
cur = cur->d;
else if (cur->c == 'U')
cur = cur->u;
res++;
}
return res;
}
int main() {
cin >> n >> m;
char a;
B.assign(n + 1, vector<item>(m + 1));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a;
B[i][j] = make_item(a);
}
int maxima = 0;
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (B[i][j].c != '.') {
int cur = modeling(i, j);
if (cur > maxima)
maxima = cur, cnt = 1;
else if (cur == maxima)
cnt++;
}
}
cout << maxima << " " << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<string> grid;
vector<vector<bool>> vis;
vector<vector<pair<int, int>>> nxtUP, nxtDown, nxtRight, nxtLeft;
const int N = 5005;
void init() {
vis = vector<vector<bool>>(n + 5, vector<bool>(m + 5));
nxtUP = vector<vector<pair<int, int>>>(n + 5, vector<pair<int, int>>(m + 5));
nxtDown =
vector<vector<pair<int, int>>>(n + 5, vector<pair<int, int>>(m + 5));
nxtRight =
vector<vector<pair<int, int>>>(n + 5, vector<pair<int, int>>(m + 5));
nxtLeft =
vector<vector<pair<int, int>>>(n + 5, vector<pair<int, int>>(m + 5));
}
void clear() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
vis[i][j] = false;
nxtRight[i][j] = nxtLeft[i][j] = nxtUP[i][j] = nxtDown[i][j] = {i, j};
}
}
}
pair<int, int> get_nxt_up(int i, int j) {
pair<int, int> nxt = nxtUP[i][j];
nxt.first--;
if (nxt.first <= -1 || nxt.second <= -1) return {-1, -1};
if (nxt.first >= n || nxt.second >= m) return {n, m};
if (!vis[nxt.first][nxt.second] && grid[nxt.first][nxt.second] != '.')
return nxtUP[i][j] = nxt;
return nxtUP[i][j] = get_nxt_up(nxt.first, nxt.second);
}
pair<int, int> get_nxt_down(int i, int j) {
pair<int, int> nxt = nxtDown[i][j];
nxt.first++;
if (nxt.first <= -1 || nxt.second <= -1) return {-1, -1};
if (nxt.first >= n || nxt.second >= m) return {n, m};
if (!vis[nxt.first][nxt.second] && grid[nxt.first][nxt.second] != '.')
return nxtDown[i][j] = nxt;
return nxtDown[i][j] = get_nxt_down(nxt.first, nxt.second);
}
pair<int, int> get_nxt_right(int i, int j) {
pair<int, int> nxt = nxtRight[i][j];
nxt.second++;
if (nxt.first <= -1 || nxt.second <= -1) return {-1, -1};
if (nxt.first >= n || nxt.second >= m) return {n, m};
if (!vis[nxt.first][nxt.second] && grid[nxt.first][nxt.second] != '.')
return nxtRight[i][j] = nxt;
return nxtRight[i][j] = get_nxt_right(nxt.first, nxt.second);
}
pair<int, int> get_nxt_left(int i, int j) {
pair<int, int> nxt = nxtLeft[i][j];
nxt.second--;
if (nxt.first <= -1 || nxt.second <= -1) return {-1, -1};
if (nxt.first >= n || nxt.second >= m) return {n, m};
if (!vis[nxt.first][nxt.second] && grid[nxt.first][nxt.second] != '.')
return nxtLeft[i][j] = nxt;
return nxtLeft[i][j] = get_nxt_left(nxt.first, nxt.second);
}
int solve(int i, int j) {
int ret = 0;
while (true) {
if (i == n || j == m || i == -1 || j == -1) break;
ret++;
vis[i][j] = true;
pair<int, int> nxt;
if (grid[i][j] == 'U') nxt = get_nxt_up(i, j);
if (grid[i][j] == 'D') nxt = get_nxt_down(i, j);
if (grid[i][j] == 'R') nxt = get_nxt_right(i, j);
if (grid[i][j] == 'L') nxt = get_nxt_left(i, j);
i = nxt.first;
j = nxt.second;
}
return ret;
}
int freq[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
init();
for (int i = 0; i < n; i++) {
string x;
cin >> x;
grid.push_back(x);
}
int mx = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '.') continue;
clear();
int curr = solve(i, j);
freq[curr]++;
mx = max(mx, curr);
}
}
cout << mx << ' ' << freq[mx];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, mn, ans, cnt, p[5005][4];
char c[5005];
int v[5005], vw;
int f(char c) {
switch (c) {
case 'L':
return 0;
case 'R':
return 1;
case 'U':
return 2;
case 'D':
return 3;
}
}
int solve(int x) {
for (int i = 0; i < mn; ++i) {
p[i][0] = i % n == 0 ? -1 : i - 1;
p[i][1] = i % n == n - 1 ? -1 : i + 1;
p[i][2] = i - n;
p[i][3] = i + n;
}
vw = x;
int ret = 0;
while (1) {
ret++;
v[x] = vw;
int z = f(c[x]);
int X = x;
while (c[X] == '.' || v[X] == vw) {
X = p[X][z];
if (!(0 <= X && X < mn)) return ret;
}
p[x][z] = X;
x = X;
}
}
int main() {
scanf("%d%d", &m, &n);
mn = m * n;
for (int i = 0; i < m; ++i) scanf("%s", c + i * n);
memset(v, -1, sizeof(v));
ans = cnt = 0;
for (int i = 0; i < mn; ++i) {
if (c[i] != '.') {
int tmp = solve(i);
if (tmp > ans) {
ans = tmp;
cnt = 1;
} else if (tmp == ans)
cnt++;
}
}
printf("%d %d\n", ans, cnt);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5005;
int up[N], down[N], left[N], right[N], n, m;
char s[N][N];
void del(int x) {
if (left[x]) right[left[x]] = right[x];
if (right[x]) left[right[x]] = left[x];
if (up[x]) down[up[x]] = down[x];
if (down[x]) up[down[x]] = up[x];
}
void pushBack(int x) {
if (left[x]) right[left[x]] = x;
if (right[x]) left[right[x]] = x;
if (up[x]) down[up[x]] = x;
if (down[x]) up[down[x]] = x;
}
int dfs(int row, int col) {
int ans = 0;
int k = 0;
int t = (row - 1) * m + col;
if (s[row][col] == 'L')
k = left[t];
else if (s[row][col] == 'R')
k = right[t];
else if (s[row][col] == 'U')
k = up[t];
else
k = down[t];
if (!k) return 1;
del(t);
ans = 1 + dfs((k - 1) / m + 1, (k - 1) % m + 1);
pushBack(t);
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++) {
left[(i - 1) * m + 1] = 0;
for (int j = 2; j <= m; j++)
if (s[i][j - 1] == '.')
left[(i - 1) * m + j] = left[(i - 1) * m + j - 1];
else
left[(i - 1) * m + j] = (i - 1) * m + j - 1;
right[i * m] = 0;
for (int j = m - 1; j; j--)
if (s[i][j + 1] == '.')
right[(i - 1) * m + j] = right[(i - 1) * m + j + 1];
else
right[(i - 1) * m + j] = (i - 1) * m + j + 1;
}
for (int j = 1; j <= m; j++) {
up[j] = 0;
for (int i = 2; i <= n; i++)
if (s[i - 1][j] == '.')
up[(i - 1) * m + j] = up[(i - 2) * m + j];
else
up[(i - 1) * m + j] = (i - 2) * m + j;
down[(n - 1) * m + j] = 0;
for (int i = n - 1; i; i--)
if (s[i + 1][j] == '.')
down[(i - 1) * m + j] = down[i * m + j];
else
down[(i - 1) * m + j] = i * m + j;
}
int ans = 1, num = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (s[i][j] == '.') continue;
int tmp = dfs(i, j);
if (tmp > ans)
ans = tmp, num = 1;
else if (tmp == ans)
num++;
}
printf("%d %d\n", ans, num);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5002;
const int N_DIR = 4;
char dir[] = {'U', 'R', 'D', 'L'};
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
string grid[MAXN];
string mat[MAXN];
vector<vector<vector<pair<int, int>>>> ashdASDHaOS;
vector<vector<vector<pair<int, int>>>> mov;
int direction[MAXN][MAXN];
inline bool is_in(int x, int y, int n, int m) {
return 0 <= x && x < n && 0 <= y && y < m;
}
void build(int n, int m) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '.') continue;
for (int k = 0; k < 4; k++) {
if (grid[i][j] == dir[k]) direction[i][j] = k;
for (int p = 1;; p++) {
int x = i + p * dx[k];
int y = j + p * dy[k];
if (is_in(x, y, n, m)) {
if (grid[x][y] != '.') {
ashdASDHaOS[i][j][k] = {x, y};
break;
}
} else {
ashdASDHaOS[i][j][k] = {x, y};
break;
}
}
}
}
}
return;
}
int solve(int x, int y, int n, int m) {
mov = ashdASDHaOS;
for (int i = 0; i < n; i++) {
mat[i] = grid[i];
}
int chips = 0;
while (is_in(x, y, n, m)) {
chips++;
mat[x][y] = '.';
int d = direction[x][y];
for (int k = 0; k < 4; k++) {
if (is_in(mov[x][y][k].first, mov[x][y][k].second, n, m)) {
int nx = mov[x][y][k].first;
int ny = mov[x][y][k].second;
mov[nx][ny][k ^ 2] = mov[x][y][k ^ 2];
}
}
pair<int, int> p = mov[x][y][d];
x = p.first;
y = p.second;
}
return chips;
}
int main(void) {
int n, m;
scanf(" %d %d", &n, &m);
ashdASDHaOS.resize(n);
for (int i = 0; i < n; i++) {
ashdASDHaOS[i].resize(m);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ashdASDHaOS[i][j].resize(4);
}
}
for (int i = 0; i < n; i++) {
cin >> grid[i];
}
int ans = 0;
int ways = 1;
build(n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '.') continue;
int chips = solve(i, j, n, m);
if (chips > ans) {
ans = chips;
ways = 1;
} else if (chips == ans) {
ways++;
}
}
}
printf("%d %d\n", ans, ways);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char c[5010][5010] = {};
short p[5001][550][4] = {};
short q[5001][550][4] = {};
short pi[550][5001][4] = {};
short qi[550][5001][4] = {};
void init() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int t = i - 1;
while (t >= 1) {
if (c[t][j] == '.')
t--;
else {
p[i][j][0] = t;
break;
}
}
t = i + 1;
while (t <= n) {
if (c[t][j] == '.')
t++;
else {
p[i][j][1] = t;
break;
}
}
t = j - 1;
while (t >= 1) {
if (c[i][t] == '.')
t--;
else {
p[i][j][2] = t;
break;
}
}
t = j + 1;
while (t <= m) {
if (c[i][t] == '.')
t++;
else {
p[i][j][3] = t;
break;
}
}
}
}
}
void pp() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 0; k <= 3; k++) {
q[i][j][k] = p[i][j][k];
}
}
}
}
int ff(int x, int y) {
int ans = 0;
pp();
while (1) {
ans++;
int w;
if (c[x][y] == 'U') w = q[x][y][0];
if (c[x][y] == 'D') w = q[x][y][1];
if (c[x][y] == 'L') w = q[x][y][2];
if (c[x][y] == 'R') w = q[x][y][3];
if (w == 0) break;
int e[4];
for (int i = 0; i <= 3; i++) e[i] = q[x][y][i];
if (e[0] != 0) {
q[e[0]][y][1] = e[1];
}
if (e[1] != 0) {
q[e[1]][y][0] = e[0];
}
if (e[2] != 0) {
q[x][e[2]][3] = e[3];
}
if (e[3] != 0) {
q[x][e[3]][2] = e[2];
}
if (c[x][y] == 'U')
x = e[0];
else if (c[x][y] == 'D')
x = e[1];
else if (c[x][y] == 'L')
y = e[2];
else if (c[x][y] == 'R')
y = e[3];
}
return ans;
}
void init1() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int t = i - 1;
while (t >= 1) {
if (c[t][j] == '.')
t--;
else {
pi[i][j][0] = t;
break;
}
}
t = i + 1;
while (t <= n) {
if (c[t][j] == '.')
t++;
else {
pi[i][j][1] = t;
break;
}
}
t = j - 1;
while (t >= 1) {
if (c[i][t] == '.')
t--;
else {
pi[i][j][2] = t;
break;
}
}
t = j + 1;
while (t <= m) {
if (c[i][t] == '.')
t++;
else {
pi[i][j][3] = t;
break;
}
}
}
}
}
void pp1() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 0; k <= 3; k++) {
qi[i][j][k] = pi[i][j][k];
}
}
}
}
int ff1(int x, int y) {
int ans = 0;
pp1();
while (1) {
ans++;
int w;
if (c[x][y] == 'U') w = qi[x][y][0];
if (c[x][y] == 'D') w = qi[x][y][1];
if (c[x][y] == 'L') w = qi[x][y][2];
if (c[x][y] == 'R') w = qi[x][y][3];
if (w == 0) break;
int e[4];
for (int i = 0; i <= 3; i++) e[i] = qi[x][y][i];
if (e[0] != 0) {
qi[e[0]][y][1] = e[1];
}
if (e[1] != 0) {
qi[e[1]][y][0] = e[0];
}
if (e[2] != 0) {
qi[x][e[2]][3] = e[3];
}
if (e[3] != 0) {
qi[x][e[3]][2] = e[2];
}
if (c[x][y] == 'U')
x = e[0];
else if (c[x][y] == 'D')
x = e[1];
else if (c[x][y] == 'L')
y = e[2];
else if (c[x][y] == 'R')
y = e[3];
}
return ans;
}
char cc;
int main() {
scanf("%d%d", &n, &m);
cc = getchar();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cc = getchar();
c[i][j] = cc;
}
cc = getchar();
}
int ansx = 0;
int ansy = 0;
if (n >= m) {
init();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (c[i][j] == '.') continue;
int tt = ff(i, j);
if (tt > ansx) {
ansx = tt;
ansy = 1;
} else if (tt == ansx) {
ansy++;
}
}
}
} else {
init1();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (c[i][j] == '.') continue;
int tt = ff1(i, j);
if (tt > ansx) {
ansx = tt;
ansy = 1;
} else if (tt == ansx) {
ansy++;
}
}
}
}
printf("%d %d", ansx, ansy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char **g;
int **lx, **rx;
int **ly, **ry;
int n, m;
template <class T>
void getarr(T **&a) {
a = (T **)malloc((n + 10) * sizeof(T *));
for (int i = 0; i < n + 10; i++) {
a[i] = (T *)malloc((m + 10) * sizeof(T));
}
}
void del(int x, int y) {
rx[x][lx[x][y]] = rx[x][y];
lx[x][rx[x][y]] = lx[x][y];
ry[ly[x][y]][y] = ry[x][y];
ly[ry[x][y]][y] = ly[x][y];
}
void init() {
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
lx[i][j] = j - 1;
rx[i][j] = j + 1;
}
lx[i][0] = m;
rx[i][m] = 0;
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= n; j++) {
ly[j][i] = j - 1;
ry[j][i] = j + 1;
}
ly[0][i] = n;
ry[n][i] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (g[i][j] == '.') {
del(i, j);
}
}
}
}
int to[300];
int solve(int x, int y) {
int cc = 0;
while (x != 0 && y != 0) {
int d = to[g[x][y]];
cc++;
del(x, y);
if (d == 0) {
x = ly[x][y];
} else if (d == 1) {
y = rx[x][y];
} else if (d == 2) {
x = ry[x][y];
} else {
y = lx[x][y];
}
}
return cc;
}
int main() {
to['U'] = 0;
to['R'] = 1;
to['D'] = 2;
to['L'] = 3;
scanf("%d%d", &n, &m);
getarr(g);
getarr(lx);
getarr(rx);
getarr(ly);
getarr(ry);
for (int i = 1; i <= n; i++) {
scanf("%s", g[i] + 1);
}
int ans1 = -1, ans2 = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (g[i][j] != '.') {
init();
int ret = solve(i, j);
if (ans1 < ret) {
ans1 = ret;
ans2 = 1;
} else if (ans1 == ret) {
ans2++;
}
}
}
}
printf("%d %d\n", ans1, ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
char s[5005], ch[] = {'U', 'L', 'R', 'D'};
int x[5005], y[5005], typ[5005], mk[5005][5005], to[5005][4], w[5005][4];
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
int n, m, tot;
int main() {
while (scanf("%d %d", &n, &m) == 2) {
tot = 0;
getchar();
for (int i(0); i < (n); ++i) {
gets(s);
for (int j(0); j < (m); ++j) {
if (s[j] != '.') {
for (int k(0); k < (4); ++k)
if (s[j] == ch[k]) {
typ[tot] = k;
mk[i][j] = tot;
x[tot] = i;
y[tot] = j;
++tot;
break;
}
} else
mk[i][j] = -1;
}
}
for (int i(0); i < (tot); ++i)
for (int j(0); j < (4); ++j) {
int tx(x[i] + dx[j]), ty(y[i] + dy[j]);
w[i][j] = -1;
while (tx >= 0 && tx < n && ty >= 0 && ty < m) {
if (mk[tx][ty] != -1) {
w[i][j] = mk[tx][ty];
break;
}
tx += dx[j];
ty += dy[j];
}
}
int len(-1), num(0);
for (int i(0); i < (tot); ++i) {
int t(i), tmp(0);
memcpy(to, w, sizeof(w));
while (t != -1) {
++tmp;
for (int j(0); j < (4); ++j)
if (to[t][j] != -1) to[to[t][j]][3 - j] = to[t][3 - j];
t = to[t][typ[t]];
}
if (tmp > len)
len = tmp, num = 1;
else if (tmp == len)
++num;
}
printf("%d %d\n", len, num);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.txt");
ofstream fout("out.txt");
const int MAXN = 5120;
char a[MAXN][MAXN];
int RCON, CCON;
int L[MAXN], R[MAXN];
int U[MAXN], D[MAXN];
void prepare() {
for (int i = (0); i <= (RCON - 1); i++) {
int l = -1;
for (int j = (0); j <= (CCON - 1); j++)
if (a[i][j] != '.') {
int ed = i * CCON + j;
L[ed] = l;
if (l != -1) R[l] = ed;
l = ed;
}
R[l] = -1;
}
for (int i = (0); i <= (CCON - 1); i++) {
int u = -1;
for (int j = (0); j <= (RCON - 1); j++)
if (a[j][i] != '.') {
int ed = j * CCON + i;
U[ed] = u;
if (u != -1) D[u] = ed;
u = ed;
}
D[u] = -1;
}
}
void del(int i, int j) {
int ed = i * CCON + j;
if (U[ed] != -1) D[U[ed]] = D[ed];
if (D[ed] != -1) U[D[ed]] = U[ed];
if (L[ed] != -1) R[L[ed]] = R[ed];
if (R[ed] != -1) L[R[ed]] = L[ed];
}
int dfs(int i, int j) {
del(i, j);
int ed = i * CCON + j;
if (a[i][j] == 'U') {
if (U[ed] == -1)
return 1;
else
return 1 + dfs(U[ed] / CCON, j);
} else if (a[i][j] == 'D') {
if (D[ed] == -1)
return 1;
else
return 1 + dfs(D[ed] / CCON, j);
} else if (a[i][j] == 'L') {
if (L[ed] == -1)
return 1;
else
return 1 + dfs(i, L[ed] % CCON);
} else if (a[i][j] == 'R') {
if (R[ed] == -1)
return 1;
else
return 1 + dfs(i, R[ed] % CCON);
}
return 0;
}
void openfile() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
void init() {
scanf("%d %d", &RCON, &CCON);
for (int i = 0; i < RCON; i++) scanf("%s", a[i]);
}
void solve() {
int ans = -1, ans2;
for (int i = (0); i <= (RCON - 1); i++)
for (int j = (0); j <= (CCON - 1); j++)
if (a[i][j] != '.') {
prepare();
int ret = dfs(i, j);
if (ret > ans)
ans = ret, ans2 = 1;
else if (ret == ans)
ans2++;
}
printf("%d %d\n", ans, ans2);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5005;
int up[N], down[N], left[N], right[N], n, m;
char s[N][N];
void del(int x) {
if (left[x]) right[left[x]] = right[x];
if (right[x]) left[right[x]] = left[x];
if (up[x]) down[up[x]] = down[x];
if (down[x]) up[down[x]] = up[x];
}
void pushBack(int x) {
if (left[x]) right[left[x]] = x;
if (right[x]) left[right[x]] = x;
if (up[x]) down[up[x]] = x;
if (down[x]) up[down[x]] = x;
}
int dfs(int row, int col) {
int ans = 0;
int k = 0;
int t = (row - 1) * m + col;
if (s[row][col] == 'L')
k = left[t];
else if (s[row][col] == 'R')
k = right[t];
else if (s[row][col] == 'U')
k = up[t];
else
k = down[t];
if (!k) return 1;
del(t);
ans = 1 + dfs((k - 1) / m + 1, (k - 1) % m + 1);
pushBack(t);
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int t = 0;
for (int k = i - 1; k && !t; k--)
if (s[k][j] != '.') t = k;
if (t) up[(i - 1) * m + j] = (t - 1) * m + j;
t = 0;
for (int k = i + 1; k <= n && !t; k++)
if (s[k][j] != '.') t = k;
if (t) down[(i - 1) * m + j] = (t - 1) * m + j;
t = 0;
for (int k = j - 1; k && !t; k--)
if (s[i][k] != '.') t = k;
if (t) left[(i - 1) * m + j] = (i - 1) * m + t;
t = 0;
for (int k = j + 1; k <= m && !t; k++)
if (s[i][k] != '.') t = k;
if (t) right[(i - 1) * m + j] = (i - 1) * m + t;
}
int ans = 1, num = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (s[i][j] == '.') continue;
int tmp = dfs(i, j);
if (tmp > ans)
ans = tmp, num = 1;
else if (tmp == ans)
num++;
}
printf("%d %d", ans, num);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 28;
const double INF = 1e12, EPS = 1e-9;
enum type { UP, DOWN, LEFT, RIGHT };
struct V {
int l, r, u, d;
type t;
};
V v[5000];
int sz;
int h, w;
void make_graph(vector<vector<int> > &node, vector<string> &in) {
vector<int> line(w, -1);
int left;
sz = 0;
for (int i = 0; i < h; i++) {
left = -1;
for (int j = 0; j < w; j++)
if (in[i][j] == '.')
node[i][j] = -1;
else {
node[i][j] = sz;
v[sz].u = line[j];
if (line[j] >= 0) v[line[j]].d = sz;
line[j] = sz;
v[sz].l = left;
if (left >= 0) v[left].r = sz;
left = sz;
const char *s = "UDLR";
for (int k = 0; k < 4; k++)
if (s[k] == in[i][j]) v[sz].t = (type)k;
v[sz].d = v[sz].r = -1;
sz++;
}
}
}
void run() {
cin >> h >> w;
vector<string> in(h);
for (int i = 0; i < h; i++) cin >> in[i];
vector<int> line(w, -1);
vector<vector<int> > node(h, vector<int>(w));
int ans = -1, ansi = 0;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
if (in[i][j] != '.') {
make_graph(node, in);
int cur = node[i][j];
int num = 0;
for (; cur != -1;) {
num++;
int l = v[cur].l, r = v[cur].r, d = v[cur].d, u = v[cur].u;
if (v[cur].t == UP)
cur = v[cur].u;
else if (v[cur].t == DOWN)
cur = v[cur].d;
else if (v[cur].t == LEFT)
cur = v[cur].l;
else
cur = v[cur].r;
if (l >= 0) v[l].r = r;
if (r >= 0) v[r].l = l;
if (u >= 0) v[u].d = d;
if (d >= 0) v[d].u = u;
}
if (ans < num) ans = num, ansi = 0;
if (ans == num) ansi++;
}
cout << ans << " " << ansi << endl;
}
int main() { run(); }
|
#include <bits/stdc++.h>
using namespace std;
short nt[5005][4];
int n, m;
char s[5010][5010];
char g[] = "URDL";
int run(int first, int second) {
int id = first * m + second;
for (int d = (0); d < (int)(4); d++) {
if (s[first][second] == g[d]) {
if (nt[id][d] == -1) break;
int nid = nt[id][d];
for (int k = (0); k < (int)(2); k++) {
int id1 = nt[id][k];
int id2 = nt[id][k + 2];
nt[id1][k + 2] = id2;
nt[id2][k] = id1;
}
int ret = run(nid / m, nid % m) + 1;
for (int k = (0); k < (int)(2); k++) {
int id1 = nt[id][k];
int id2 = nt[id][k + 2];
nt[id1][k + 2] = id;
nt[id2][k] = id;
}
return ret;
}
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (int)(n); i++) scanf("%s", s[i]);
memset(nt, -1, sizeof(nt));
int a[5010];
memset(a, -1, sizeof(a));
for (int i = (0); i < (int)(n); i++) {
for (int j = (0); j < (int)(m); j++) {
if (s[i][j] == '.') continue;
int id = i * m + j;
if (a[j] != -1) {
nt[a[j]][2] = id;
nt[id][0] = a[j];
}
a[j] = id;
}
}
memset(a, -1, sizeof(a));
for (int j = (0); j < (int)(m); j++) {
for (int i = (0); i < (int)(n); i++) {
if (s[i][j] == '.') continue;
int id = i * m + j;
if (a[i] != -1) {
nt[a[i]][1] = id;
nt[id][3] = a[i];
}
a[i] = id;
}
}
int ans = 0, cnt = 0;
for (int i = (0); i < (int)(n); i++) {
for (int j = (0); j < (int)(m); j++) {
if (s[i][j] == '.') continue;
int first = i, second = j;
int cc = run(first, second);
if (cc > ans)
ans = cc, cnt = 1;
else if (cc == ans)
cnt++;
}
}
printf("%d %d\n", ans, cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 10000;
char DP[maxN][maxN];
int nr, nc;
int L[maxN], R[maxN];
int U[maxN], D[maxN];
void getUDLR() {
for (int i = 0; i < nr; i++) {
int l = -1;
for (int j = 0; j < nc; j++)
if (DP[i][j] != '.') {
int idx = i * nc + j;
L[idx] = l;
if (l != -1) R[l] = idx;
l = idx;
}
R[l] = -1;
}
for (int i = 0; i < nc; i++) {
int u = -1;
for (int j = 0; j < nr; j++)
if (DP[j][i] != '.') {
int idx = j * nc + i;
U[idx] = u;
if (u != -1) D[u] = idx;
u = idx;
}
D[u] = -1;
}
}
void del(int i, int j) {
int idx = i * nc + j;
if (U[idx] != -1) D[U[idx]] = D[idx];
if (D[idx] != -1) U[D[idx]] = U[idx];
if (L[idx] != -1) R[L[idx]] = R[idx];
if (R[idx] != -1) L[R[idx]] = L[idx];
}
int dfs(int i, int j) {
del(i, j);
int idx = i * nc + j;
if (DP[i][j] == 'U') {
if (U[idx] == -1)
return 1;
else
return 1 + dfs(U[idx] / nc, j);
} else if (DP[i][j] == 'D') {
if (D[idx] == -1)
return 1;
else
return 1 + dfs(D[idx] / nc, j);
} else if (DP[i][j] == 'L') {
if (L[idx] == -1)
return 1;
else
return 1 + dfs(i, L[idx] % nc);
} else if (DP[i][j] == 'R') {
if (R[idx] == -1)
return 1;
else
return 1 + dfs(i, R[idx] % nc);
}
}
int main() {
scanf("%d %d", &nr, &nc);
for (int i = 0; i < nr; i++) scanf("%s", DP[i]);
int num, max = -1;
for (int i = 0; i < nr; i++)
for (int j = 0; j < nc; j++)
if (DP[i][j] != '.') {
getUDLR();
int tmp = dfs(i, j);
if (tmp > max)
max = tmp, num = 1;
else if (tmp == max)
num++;
}
printf("%d %d\n", max, num);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5005;
int ndx[maxn];
int back[maxn];
int u[maxn], d[maxn], l[maxn], r[maxn];
char str[maxn][maxn];
int n, m;
int bu[maxn], bd[maxn], bl[maxn], br[maxn];
inline void build() {
int i, j, x;
for (i = 0; i < n; i++) {
x = -1;
for (j = 0; j < m; j++)
if (str[i][j] != '.') {
if (x == -1)
l[ndx[i * m + j]] = -1;
else
l[ndx[i * m + j]] = ndx[i * m + x];
x = j;
}
x = -1;
for (j = m - 1; j >= 0; j--)
if (str[i][j] != '.') {
if (x == -1)
r[ndx[i * m + j]] = -1;
else
r[ndx[i * m + j]] = ndx[i * m + x];
x = j;
}
}
for (j = 0; j < m; j++) {
x = -1;
for (i = 0; i < n; i++)
if (str[i][j] != '.') {
if (x == -1)
u[ndx[i * m + j]] = -1;
else
u[ndx[i * m + j]] = ndx[x * m + j];
x = i;
}
x = -1;
for (i = n - 1; i >= 0; i--)
if (str[i][j] != '.') {
if (x == -1)
d[ndx[i * m + j]] = -1;
else
d[ndx[i * m + j]] = ndx[x * m + j];
x = i;
}
}
}
inline void remove(int x) {
if (u[x] != -1) d[u[x]] = d[x];
if (d[x] != -1) u[d[x]] = u[x];
if (l[x] != -1) r[l[x]] = r[x];
if (r[x] != -1) l[r[x]] = l[x];
}
inline int travel(int x) {
int step = 0;
int i, j;
while (x != -1) {
step++;
i = back[x] / m;
j = back[x] % m;
remove(x);
switch (str[i][j]) {
case 'U':
x = u[x];
break;
case 'D':
x = d[x];
break;
case 'L':
x = l[x];
break;
case 'R':
x = r[x];
break;
}
}
return step;
}
int main() {
int i, j, num, ans, tot, t = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", str[i]);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (str[i][j] != '.') {
ndx[i * m + j] = ++t;
back[t] = i * m + j;
}
ans = tot = 0;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (str[i][j] != '.') {
build();
num = travel(ndx[i * m + j]);
if (num > ans) {
ans = num;
tot = 1;
} else if (num == ans)
tot++;
}
printf("%d %d\n", ans, tot);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int up[5002], dw[5002], pl[5002], pr[5002];
int tup[5002], tdw[5002], tpl[5002], tpr[5002];
char mp[5002][5002];
int n, m;
void cpy() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
tup[i * m + j] = up[i * m + j];
tdw[i * m + j] = dw[i * m + j];
tpl[i * m + j] = pl[i * m + j];
tpr[i * m + j] = pr[i * m + j];
}
}
}
void del(int p) {
tup[tdw[p]] = tup[p];
tpl[tpr[p]] = tpl[p];
tpr[tpl[p]] = tpr[p];
tdw[tup[p]] = tdw[p];
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> mp[i][j];
}
}
memset(up, -1, sizeof(up));
memset(dw, -1, sizeof(dw));
memset(pr, -1, sizeof(pr));
memset(pl, -1, sizeof(pl));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mp[i][j] == '.') continue;
for (int k = i - 1; k >= 0; k--)
if (mp[k][j] != '.') {
up[i * m + j] = k * m + j;
break;
}
for (int k = j - 1; k >= 0; k--)
if (mp[i][k] != '.') {
pl[i * m + j] = i * m + k;
break;
}
for (int k = i + 1; k < n; k++)
if (mp[k][j] != '.') {
dw[i * m + j] = k * m + j;
break;
}
for (int k = j + 1; k < m; k++)
if (mp[i][k] != '.') {
pr[i * m + j] = i * m + k;
break;
}
}
}
int minstep = 1, num = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mp[i][j] == '.') continue;
cpy();
int x = i, y = j;
int step = 1;
while (1) {
int pos = x * m + y;
if (mp[x][y] == 'U' && tup[pos] >= 0) {
x = tup[pos] / m;
y = tup[pos] % m;
} else if (mp[x][y] == 'D' && tdw[pos] >= 0) {
x = tdw[pos] / m;
y = tdw[pos] % m;
} else if (mp[x][y] == 'R' && tpr[pos] >= 0) {
x = tpr[pos] / m;
y = tpr[pos] % m;
} else if (mp[x][y] == 'L' && tpl[pos] >= 0) {
x = tpl[pos] / m;
y = tpl[pos] % m;
} else
break;
del(pos);
step++;
}
if (minstep == step)
num++;
else if (minstep < step) {
minstep = step;
num = 1;
}
}
}
cout << minstep << " " << num << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int dx[4] = {0, -1, 0, 1};
const int dy[4] = {-1, 0, 1, 0};
int n;
int m;
string g[5000];
int v[5000][4], t[5000];
int was[5000];
int ct;
int go(int i, int j, int t) {
if (i < 0 || j < 0 || i >= n || j >= m) return 0;
if (was[i * m + j] != ct && g[i][j] != '.') return 0;
return v[i * m + j][t] = v[i * m + j][t] + go(i + dx[t] * v[i * m + j][t],
j + dy[t] * v[i * m + j][t], t);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> g[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
t[i * m + j] = int(g[i][j] == 'U') + 2 * int(g[i][j] == 'R') +
3 * int(g[i][j] == 'D') + 4 * int(g[i][j] == '.');
int ans = 0, cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (g[i][j] != '.') {
for (int a = 0; a < n; a++)
for (int b = 0; b < m; b++)
for (int k = 0; k < 4; k++) v[a * m + b][k] = 1;
ct++;
int a = i, b = j, cur = 0;
while (true) {
cur++;
was[a * m + b] = ct;
int tt = t[a * m + b];
int d = go(a, b, tt);
if (a + dx[tt] * d < 0 || a + dx[tt] * d >= n || b + dy[tt] * d < 0 ||
b + dy[tt] * d >= m)
break;
a += dx[tt] * d;
b += dy[tt] * d;
}
if (cur > ans) ans = cur, cnt = 0;
if (cur == ans) cnt++;
}
printf("%d %d\n", ans, cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int head = 0;
const int INF = 1000000;
int n, m;
int O[100005], C[100005], S[100005], Row[100005];
int L[100005], R[100005], U[100005], D[100005];
vector<char> str[100005];
char Dir[100005];
void remove(const int &cur) {
L[R[cur]] = L[cur];
R[L[cur]] = R[cur];
U[D[cur]] = U[cur];
D[U[cur]] = D[cur];
}
void resume(const int &cur) {
U[D[cur]] = cur;
D[U[cur]] = cur;
L[R[cur]] = cur;
R[L[cur]] = cur;
}
void dfs(int cur, int &cnt) {
if (Dir[cur] == 'L') {
if (C[L[cur]] == 0 || C[L[cur]] >= C[cur]) return;
remove(cur);
cnt++;
dfs(L[cur], cnt);
resume(cur);
} else if (Dir[cur] == 'R') {
if (C[R[cur]] == 0 || C[R[cur]] <= C[cur]) return;
remove(cur);
cnt++;
dfs(R[cur], cnt);
resume(cur);
} else if (Dir[cur] == 'U') {
if (Row[U[cur]] == 0 || Row[U[cur]] >= Row[cur]) return;
remove(cur);
cnt++;
dfs(U[cur], cnt);
resume(cur);
} else {
if (Row[D[cur]] == 0 || Row[D[cur]] <= Row[cur]) return;
remove(cur);
cnt++;
dfs(D[cur], cnt);
resume(cur);
}
}
int main() {
int i, j, cnt, k;
int Cnum;
int Rnum;
char temp[5005];
while (scanf("%d%d", &n, &m) != EOF) {
for (i = head; i <= m; i++) {
R[i] = (i + 1) % (m + 1);
L[i] = (i - 1 + m + 1) % (m + 1);
U[i] = D[i] = i;
S[i] = 0;
Row[i] = C[i] = 0;
}
for (i = 1; i <= n; i++) {
str[i].clear();
scanf("%s", temp);
str[i].push_back('#');
for (j = 0; j < m; j++) str[i].push_back(temp[j]);
}
cnt = m + 1;
for (i = 1; i <= n; i++) {
Rnum = -1;
for (j = 1; j <= m; j++) {
if (str[i][j] == '.') continue;
Dir[cnt] = str[i][j];
Cnum = j;
U[cnt] = U[Cnum];
D[U[Cnum]] = cnt;
U[Cnum] = cnt;
D[cnt] = Cnum;
Row[cnt] = i;
C[cnt] = j;
if (Rnum == -1) {
L[cnt] = R[cnt] = cnt;
Rnum = cnt;
} else {
L[cnt] = L[Rnum];
R[L[Rnum]] = cnt;
L[Rnum] = cnt;
R[cnt] = Rnum;
}
cnt++;
}
}
int ans = 0, count = 0;
for (i = m + 1; i < cnt; i++) {
remove(i);
int temp = 1;
dfs(i, temp);
if (temp > ans)
ans = temp, count = 1;
else if (temp == ans)
count++;
resume(i);
}
printf("%d %d\n", ans, count);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
typedef struct node {
char dir;
int r, c;
struct node *left, *right, *up, *down;
node(char dir = '-', int r = -1, int c = -1) : dir(dir), r(r), c(c) {
left = right = up = down = 0;
}
} node;
char a[N];
int R, C;
void remove(node *x) {
node *l = x->left;
node *r = x->right;
node *u = x->up;
node *d = x->down;
if (l) l->right = r;
if (r) r->left = l;
if (u) u->down = d;
if (d) d->up = u;
}
int solve(int d) {
node b[R][C];
int k = 0;
for (int i = (0), _b = (R); i < (_b); ++i)
for (int j = (0), _b = (C); j < (_b); ++j) b[i][j] = node(a[k++], i, j);
for (int i = (0), _b = (R); i < (_b); ++i) {
node *prev = 0;
for (int j = (0), _b = (C); j < (_b); ++j) {
if (b[i][j].dir == '.') continue;
if (!prev)
prev = &b[i][j];
else {
prev->right = &b[i][j];
b[i][j].left = prev;
prev = &b[i][j];
}
}
}
for (int j = (0), _b = (C); j < (_b); ++j) {
node *prev = 0;
for (int i = (0), _b = (R); i < (_b); ++i) {
if (b[i][j].dir == '.') continue;
if (!prev)
prev = &b[i][j];
else {
prev->down = &b[i][j];
b[i][j].up = prev;
prev = &b[i][j];
}
}
}
int ret = 0;
int r = d / C, c = d % C;
while (true) {
char ch = b[r][c].dir;
if (ch == 'U') {
++ret;
int i = -1, j = -1;
if (b[r][c].up) {
i = b[r][c].up->r;
j = b[r][c].up->c;
}
remove(&b[r][c]);
if (i == -1) break;
r = i;
c = j;
} else if (ch == 'D') {
++ret;
int i = -1, j = -1;
if (b[r][c].down) {
i = b[r][c].down->r;
j = b[r][c].down->c;
}
remove(&b[r][c]);
if (i == -1) break;
r = i;
c = j;
} else if (ch == 'L') {
++ret;
int i = -1, j = -1;
if (b[r][c].left) {
i = b[r][c].left->r;
j = b[r][c].left->c;
}
remove(&b[r][c]);
if (i == -1) break;
r = i;
c = j;
} else if (ch == 'R') {
++ret;
int i = -1, j = -1;
if (b[r][c].right) {
i = b[r][c].right->r;
j = b[r][c].right->c;
}
remove(&b[r][c]);
if (i == -1) break;
r = i;
c = j;
}
}
return ret;
}
int main(int argc, char *argv[]) {
cin >> R >> C;
char ch;
for (int i = (0), _b = (R * C); i < (_b); ++i) cin >> a[i];
int ans = 0, cnt = 0;
for (int i = (0), _b = (R * C); i < (_b); ++i) {
if (a[i] == '.') continue;
int x = solve(i);
if (x > ans) {
ans = x;
cnt = 1;
} else if (x == ans)
++cnt;
}
printf("%d %d\n", ans, cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 1;
vector<char> g[N];
vector<int> l[N], r[N], u[N], d[N];
int n, m;
void read() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
r[i].resize(m), l[i].resize(m), u[i].resize(m), d[i].resize(m);
string str;
cin >> str;
for (int j = 0; j < m; j++) g[i].push_back(str[j]);
}
}
void init() {
for (int i = 0; i < n; i++) {
int last = -1;
for (int j = 0; j < m; j++) {
l[i][j] = last;
if (g[i][j] != '.') last = j;
}
}
for (int i = 0; i < n; i++) {
int last = -1;
for (int j = m - 1; j >= 0; j--) {
r[i][j] = last;
if (g[i][j] != '.') last = j;
}
}
for (int j = 0; j < m; j++) {
int last = -1;
for (int i = 0; i < n; i++) {
u[i][j] = last;
if (g[i][j] != '.') last = i;
}
}
for (int j = 0; j < m; j++) {
int last = -1;
for (int i = n - 1; i >= 0; i--) {
d[i][j] = last;
if (g[i][j] != '.') last = i;
}
}
}
void modify(int i, int j) {
if (l[i][j] != -1) r[i][l[i][j]] = r[i][j];
if (r[i][j] != -1) l[i][r[i][j]] = l[i][j];
if (u[i][j] != -1) d[u[i][j]][j] = d[i][j];
if (d[i][j] != -1) u[d[i][j]][j] = u[i][j];
}
int start(int i, int j) {
if (g[i][j] == '.') return -1;
if (g[i][j] == 'L') {
if (l[i][j] == -1) return 1;
modify(i, j);
return start(i, l[i][j]) + 1;
} else if (g[i][j] == 'R') {
if (r[i][j] == -1) return 1;
modify(i, j);
return start(i, r[i][j]) + 1;
} else if (g[i][j] == 'U') {
if (u[i][j] == -1) return 1;
modify(i, j);
return start(u[i][j], j) + 1;
} else if (g[i][j] == 'D') {
if (d[i][j] == -1) return 1;
modify(i, j);
return start(d[i][j], j) + 1;
}
}
void solve() {
int ans = -1, cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
init();
int ret = start(i, j);
if (ret > ans) cnt = 0, ans = ret;
if (ret == ans) cnt++;
}
}
cout << ans << ' ' << cnt << '\n';
}
void test() {
init();
cout << start(2, 2) << '\n';
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
int n, m;
char str[5010][5010];
int **L, **R, **U, **D;
void Allocate() {
int i;
L = (int **)malloc(n * sizeof(int *));
for (i = 0; i < n; i++) L[i] = (int *)malloc(m * sizeof(int));
R = (int **)malloc(n * sizeof(int *));
for (i = 0; i < n; i++) R[i] = (int *)malloc(m * sizeof(int));
U = (int **)malloc(n * sizeof(int *));
for (i = 0; i < n; i++) U[i] = (int *)malloc(m * sizeof(int));
D = (int **)malloc(n * sizeof(int *));
for (i = 0; i < n; i++) D[i] = (int *)malloc(m * sizeof(int));
}
void Pregenerate() {
int i, j, k;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
U[i][j] = D[i][j] = L[i][j] = R[i][j] = -1;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (i) {
if (str[i - 1][j] == '.')
U[i][j] = U[i - 1][j];
else
U[i][j] = i - 1;
}
if (j) {
if (str[i][j - 1] == '.')
L[i][j] = L[i][j - 1];
else
L[i][j] = j - 1;
}
}
}
for (i = n - 1; i >= 0; i--) {
for (j = m - 1; j >= 0; j--) {
if ((i + 1) != n) {
if (str[i + 1][j] == '.')
D[i][j] = D[i + 1][j];
else
D[i][j] = i + 1;
}
if ((j + 1) != m) {
if (str[i][j + 1] == '.')
R[i][j] = R[i][j + 1];
else
R[i][j] = j + 1;
}
}
}
}
void Update(int i, int j) {
if (D[i][j] != -1) U[D[i][j]][j] = U[i][j];
if (U[i][j] != -1) D[U[i][j]][j] = D[i][j];
if (R[i][j] != -1) L[i][R[i][j]] = L[i][j];
if (L[i][j] != -1) R[i][L[i][j]] = R[i][j];
}
int F(int i, int j) {
int k, l, counter = 0;
while (i >= 0 && j >= 0 && i < n && j < m) {
counter++;
Update(i, j);
if (str[i][j] == 'U')
i = U[i][j];
else if (str[i][j] == 'D')
i = D[i][j];
else if (str[i][j] == 'L')
j = L[i][j];
else if (str[i][j] == 'R')
j = R[i][j];
}
return counter;
}
int main() {
int i, j, k;
while (scanf("%d %d", &n, &m) != EOF) {
for (i = 0; i < n; i++) scanf("%s", str[i]);
Allocate();
int res = 0, counter = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (str[i][j] != '.') {
Pregenerate();
int x = F(i, j);
if (x > res)
res = x, counter = 1;
else if (x == res)
counter++;
}
}
}
printf("%d %d\n", res, counter);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fx[] = {-1, 0, 1, 0}, fy[] = {0, 1, 0, -1};
int n, m, res, cnt;
int ch, col;
vector<int> a[5001], w[5001];
vector<vector<int> > nx[5001], mx[5001], ny[5001], my[5001];
void dfs(int x, int y, int dir) {
cnt++;
w[x][y] = col;
int xx, yy;
while (1) {
xx = nx[x][y][dir];
yy = ny[x][y][dir];
if ((xx < 0 || xx >= n || yy < 0 || yy >= m) ||
(w[xx][yy] != col && a[xx][yy] >= 0))
break;
nx[x][y][dir] = nx[xx][yy][dir];
ny[x][y][dir] = ny[xx][yy][dir];
}
xx = nx[x][y][dir];
yy = ny[x][y][dir];
if (xx >= 0 && xx < n && yy >= 0 && yy < m) dfs(xx, yy, a[xx][yy]);
}
int main() {
scanf("%d %d\n", &n, &m);
for (int i = 0; i < n; i++)
a[i].resize(m), w[i].resize(m), mx[i].resize(m), my[i].resize(m),
nx[i].resize(m), ny[i].resize(m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
nx[i][j].resize(4), ny[i][j].resize(4), mx[i][j].resize(4),
my[i][j].resize(4);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ch = getchar();
if (ch == 'U') a[i][j] = 0;
if (ch == 'R') a[i][j] = 1;
if (ch == 'D') a[i][j] = 2;
if (ch == 'L') a[i][j] = 3;
if (ch == '.') a[i][j] = -1;
}
scanf("\n");
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++)
mx[i][j][k] = i + fx[k], my[i][j][k] = j + fy[k];
int amo = 0;
for (int i = 0; i < n; i++)
for (int j = 0, ii, jj, k; j < m; j++) {
if (a[i][j] < 0) continue;
for (ii = 0; ii < n; ii++)
for (jj = 0; jj < m; jj++)
for (k = 0; k < 4; k++)
nx[ii][jj][k] = mx[ii][jj][k], ny[ii][jj][k] = my[ii][jj][k];
cnt = 0;
col++;
dfs(i, j, a[i][j]);
if (res == cnt)
amo++;
else if (res < cnt)
res = cnt, amo = 1;
}
printf("%d %d\n", res, amo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
struct Node {
int next[4];
Node() {}
Node(int a, int b, int c, int d) {
next[0] = a;
next[1] = b;
next[2] = c;
next[3] = d;
}
};
Node* arr[5000];
char ch[5000][5001];
bool isValid(int y, int x) {
if (y >= 0 && y < N && x >= 0 && x < M) {
return true;
} else {
return false;
}
}
bool isY(int y) { return y >= 0 && y < N; }
bool isX(int x) { return x >= 0 && x < M; }
int Count(int y, int x, int way) {
if (!isValid(y, x)) {
return 0;
} else {
int pos;
if (ch[y][x] == 'U') {
pos = 0;
} else if (ch[y][x] == 'D') {
pos = 1;
} else if (ch[y][x] == 'L') {
pos = 2;
} else if (ch[y][x] == 'R') {
pos = 3;
} else {
pos = way;
}
if (isY(arr[y][x].next[0])) {
int index = arr[y][x].next[0];
arr[index][x].next[1] = arr[y][x].next[1];
}
if (isY(arr[y][x].next[1])) {
int index = arr[y][x].next[1];
arr[index][x].next[0] = arr[y][x].next[0];
}
if (isX(arr[y][x].next[2])) {
int index = arr[y][x].next[2];
arr[y][index].next[3] = arr[y][x].next[3];
}
if (isX(arr[y][x].next[3])) {
int index = arr[y][x].next[3];
arr[y][index].next[2] = arr[y][x].next[2];
}
if (pos % 4 < 2) {
return (ch[y][x] != '.') + Count(arr[y][x].next[pos], x, pos);
} else {
return (ch[y][x] != '.') + Count(y, arr[y][x].next[pos], pos);
}
}
}
void reset() {
for (int(n) = 0; n < (int)N; n++) {
for (int(m) = 0; m < (int)M; m++) {
arr[n][m] = Node(n - 1, n + 1, m - 1, m + 1);
}
}
}
int main() {
scanf("%d", &N);
;
scanf("%d", &M);
;
for (int(n) = 0; n < (int)N; n++) {
arr[n] = new Node[M];
scanf("%s", ch[n]);
}
int MAX = -1;
int counter = 0;
for (int(n) = 0; n < (int)N; n++) {
for (int(m) = 0; m < (int)M; m++) {
if (ch[n][m] != '.') {
reset();
int val = Count(n, m, 0);
if (val == MAX) {
counter++;
} else if (val > MAX) {
MAX = val;
counter = 1;
}
}
}
}
printf("%d %d\n", MAX, counter);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int powmod(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
char ch[10005];
char chcp[10005];
int dpr[10005][4];
int dpc[10005][4];
int n, m;
int ggg[2000];
int dr[] = {0, 1, 0, -1};
int dc[] = {1, 0, -1, 0};
string grid;
bool inside(int r, int c) { return r >= 0 && r < n && c >= 0 && c < m; }
pair<int, int> move(int r, int c, int ggg) {
if (!inside(r, c)) return make_pair(r, c);
if (chcp[r * m + c] != '.') return make_pair(r, c);
if (dpr[r * m + c][ggg] == -10) {
dpr[r * m + c][ggg] = r + dr[ggg];
dpc[r * m + c][ggg] = c + dc[ggg];
}
pair<int, int> hasil = move(dpr[r * m + c][ggg], dpc[r * m + c][ggg], ggg);
dpr[r * m + c][ggg] = hasil.first;
dpc[r * m + c][ggg] = hasil.second;
return hasil;
}
int main() {
ggg['R'] = 0;
ggg['D'] = 1;
ggg['L'] = 2;
ggg['U'] = 3;
cin >> n >> m;
int best = 0;
int ret = 0;
for (int i = (int)0; i <= (int)n - 1; i++) {
cin >> grid;
for (int j = i * m; j < (i + 1) * m; ++j) ch[j] = grid[j - i * m];
}
for (int ir = (int)0; ir <= (int)n - 1; ir++)
for (int ic = (int)0; ic <= (int)m - 1; ic++)
if (ch[ir * m + ic] != '.') {
for (int r = (int)0; r <= (int)n * m - 1; r++)
for (int d = (int)0; d <= (int)3; d++) dpr[r][d] = dpc[r][d] = -10;
for (int r = (int)0; r <= (int)n * m - 1; r++) chcp[r] = ch[r];
int moves = 0;
int r = ir, c = ic;
while (inside(r, c)) {
++moves;
int a = ggg[(int)chcp[r * m + c]];
chcp[r * m + c] = '.';
pair<int, int> p = move(r, c, a);
r = p.first;
c = p.second;
}
if (moves > best) {
best = moves;
ret = 0;
}
if (moves == best) ++ret;
}
cout << best << " " << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int get(int i, int j, int m) { return j + i * m; }
int g(char c) {
if (c == 'U') return 3;
if (c == 'R') return 0;
if (c == 'L') return 1;
if (c == 'D') return 2;
return 0;
}
int main() {
int a[6000][4];
int gg[6000];
memset(a, -1, sizeof(a));
string s[5000];
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int nc = get(i, j, m);
gg[nc] = g(s[i][j]);
}
}
for (int i = 0; i < n; i++) {
int cur = -1;
for (int j = 0; j < m; j++) {
if (s[i][j] != '.') {
int nc = get(i, j, m);
if (cur != -1) a[cur][0] = nc;
cur = nc;
}
}
}
for (int i = 0; i < n; i++) {
int cur = -1;
for (int j = m - 1; j >= 0; j--) {
if (s[i][j] != '.') {
int nc = get(i, j, m);
if (cur != -1) a[cur][1] = nc;
cur = nc;
}
}
}
for (int i = 0; i < m; i++) {
int cur = -1;
for (int j = 0; j < n; j++) {
if (s[j][i] != '.') {
int nc = get(j, i, m);
if (cur != -1) a[cur][2] = nc;
cur = nc;
}
}
}
for (int i = 0; i < m; i++) {
int cur = -1;
for (int j = n - 1; j >= 0; j--) {
if (s[j][i] != '.') {
int nc = get(j, i, m);
if (cur != -1) a[cur][3] = nc;
cur = nc;
}
}
}
int best = -1;
int bn = 0;
int mn = m * n;
int z[4] = {1, 0, 3, 2};
for (int i = 0; i < mn; i++) {
if (s[i / m][i % m] != '.') {
int c[6000][4];
memcpy(c, a, sizeof(a));
int cur = i;
int cnt = 0;
while (cur != -1) {
for (int k = 0; k < 4; k++) {
int t = c[cur][k];
if (t != -1) {
c[t][z[k]] = c[cur][z[k]];
}
}
cnt++;
cur = c[cur][gg[cur]];
}
if (cnt > best) {
best = cnt;
bn = 1;
} else if (cnt == best) {
bn++;
}
}
}
cout << best << " " << bn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
inline string get() {
char ch[2000010];
scanf("%s", ch);
return ch;
}
inline void read(long long *a, long long n) {
for (long long i = 0; i < n; i++) a[i] = in();
}
template <class blank>
inline void out(blank x) {
cout << x << "\n";
exit(0);
}
template <class blank>
inline void smin(blank &a, blank b) {
a = min(a, b);
}
template <class blank>
inline void smax(blank &a, blank b) {
a = max(a, b);
}
const long long maxn = 1e5 + 10;
const long long maxm = 1e6 + 10;
const long long maxlg = 21;
const long long base = 29;
const long long mod = 1e9 + 7;
const long long INF = 1e18 + 10;
const long long SQ = 317 + 5;
struct node {
node *right, *left, *up, *down;
char ch;
node() { right = left = up = down = NULL; }
} * cell[5005], *cpcell[5005];
string s[maxn];
long long res, cnt, n, m;
inline long long dfs(node *node) {
long long ret = 1;
if (node->left != NULL) node->left->right = node->right;
if (node->right != NULL) node->right->left = node->left;
if (node->down != NULL) node->down->up = node->up;
if (node->up != NULL) node->up->down = node->down;
if (node->ch == 'U') {
if (node->up != NULL) return ret + dfs(node->up);
}
if (node->ch == 'D') {
if (node->down != NULL) {
return ret + dfs(node->down);
}
}
if (node->ch == 'L')
if (node->left != NULL) return ret + dfs(node->left);
if (node->ch == 'R')
if (node->right != NULL) return ret + dfs(node->right);
return ret;
}
int32_t main() {
n = in(), m = in();
for (long long i = 0; i < n; i++) {
s[i] = get();
for (long long j = 0; j < m; j++) {
cell[i * m + j] = new node();
cell[i * m + j]->ch = s[i][j];
cpcell[i * m + j] = new node();
}
}
for (long long startX = 0; startX < n; startX++) {
for (long long startY = 0; startY < m; startY++) {
if (s[startX][startY] == '.') continue;
for (long long i = 0; i < n; i++) {
long long preLeft = -1;
for (long long j = 0; j < m; j++) {
if (s[i][j] == '.') continue;
long long nodeId = i * m + j;
if (preLeft + 1) {
cell[preLeft]->right = cell[nodeId];
cell[nodeId]->left = cell[preLeft];
}
preLeft = nodeId;
}
}
for (long long j = 0; j < m; j++) {
long long preUp = -1;
for (long long i = 0; i < n; i++) {
if (s[i][j] == '.') continue;
long long nodeId = i * m + j;
if (preUp + 1)
cell[preUp]->down = cell[nodeId], cell[nodeId]->up = cell[preUp];
preUp = nodeId;
}
}
long long val = dfs(cell[startX * m + startY]);
if (val == res)
cnt++;
else if (val > res)
cnt = 1, res = val;
}
}
cout << res << " " << cnt << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long MOD = 257;
int n, m;
string s[5005];
int L[5005], R[5005], U[5005], D[5005];
void init() {
int b, pos;
for (int i = 0; i < n; i++) {
b = -1;
for (int j = 0; j < m; j++) {
if (s[i][j] != '.') {
pos = i * m + j;
L[pos] = b;
if (b != -1) R[b] = pos;
b = pos;
}
}
R[b] = -1;
}
for (int i = 0; i < m; i++) {
b = -1;
for (int j = 0; j < n; j++) {
if (s[j][i] != '.') {
pos = j * m + i;
U[pos] = b;
if (b != -1) {
D[b] = pos;
}
b = pos;
}
}
D[b] = -1;
}
}
int dfs(int now) {
int x = now / m, y = now % m;
if (L[now] != -1) R[L[now]] = R[now];
if (R[now] != -1) L[R[now]] = L[now];
if (U[now] != -1) D[U[now]] = D[now];
if (D[now] != -1) U[D[now]] = U[now];
int go;
if (s[x][y] == 'U')
go = U[now];
else if (s[x][y] == 'D')
go = D[now];
else if (s[x][y] == 'L')
go = L[now];
else if (s[x][y] == 'R')
go = R[now];
if (go == -1) return 1;
return dfs(go) + 1;
}
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
int ans = 0, num = 0, tmp;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] != '.') {
init();
tmp = dfs(i * m + j);
if (tmp == ans)
num++;
else if (tmp > ans) {
ans = tmp;
num = 1;
}
}
}
}
cout << ans << " " << num << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
char s[maxn];
int n, m;
struct Node {
int l, r, u, d;
void init() { l = r = u = d = -1; }
} node[maxn];
void build() {
int i, j, k;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
int cur = i * m + j;
node[cur].init();
if (s[cur] == '.') continue;
for (k = i + 1; k < n; k++)
if (s[k * m + j] != '.') break;
if (k < n) node[cur].d = k * m + j;
for (k = i - 1; k >= 0; k--)
if (s[k * m + j] != '.') break;
if (k >= 0) node[cur].u = k * m + j;
for (k = j - 1; k >= 0; k--)
if (s[i * m + k] != '.') break;
if (k >= 0) node[cur].l = i * m + k;
for (k = j + 1; k < m; k++)
if (s[i * m + k] != '.') break;
if (k < m) node[cur].r = i * m + k;
}
}
void lr(int cur) {
int l = node[cur].l, r = node[cur].r;
if (l == -1) {
if (r == -1) return;
node[r].l = -1;
} else {
if (r == -1)
node[l].r = -1;
else {
node[l].r = r;
node[r].l = l;
}
}
}
void ud(int cur) {
int u = node[cur].u, d = node[cur].d;
if (u == -1) {
if (d == -1) return;
node[d].u = u;
} else {
if (d == -1)
node[u].d = -1;
else {
node[d].u = u;
node[u].d = d;
}
}
}
int solve(int x, int y) {
build();
int cur = x * m + y;
int ans = 0;
while (cur != -1) {
ans++;
int tp = cur;
switch (s[cur]) {
case 'D':
cur = node[cur].d;
break;
case 'U':
cur = node[cur].u;
break;
case 'L':
cur = node[cur].l;
break;
case 'R':
cur = node[cur].r;
break;
}
lr(tp);
ud(tp);
}
return ans;
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
int i, j;
for (i = 0; i < n; i++) scanf("%s", s + i * m);
int ans = 0, num = 1, tmp;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
if (s[i * m + j] == '.') continue;
tmp = solve(i, j);
if (tmp > ans)
ans = tmp, num = 1;
else if (tmp == ans)
num++;
}
printf("%d %d\n", ans, num);
}
return 0;
}
|
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
const long long MAXN = 1e6 + 1;
using namespace std;
long long readInt() {
bool minus1 = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus1 = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus1)
return -result;
else
return result;
}
const int N = 5005;
int usti[N];
int asti[N];
int onni[N];
int soli[N];
int USTI[N];
int ASTI[N];
int ONNI[N];
int SOLI[N];
char letter[N];
int num[N][N];
char a[N][N];
int main() {
int K = 0;
int n = readInt(), m = readInt();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] != '.') {
K++;
num[i][j] = K;
letter[K] = a[i][j];
}
}
}
int tmp;
for (int i = 1; i <= n; i++) {
tmp = -1;
for (int j = 1; j <= m; j++) {
if (a[i][j] != '.') {
soli[num[i][j]] = tmp, tmp = num[i][j];
}
}
tmp = -1;
for (int j = m; j >= 1; j--) {
if (a[i][j] != '.') {
onni[num[i][j]] = tmp, tmp = num[i][j];
}
}
}
for (int j = 1; j <= m; j++) {
tmp = -1;
for (int i = 1; i <= n; i++) {
if (a[i][j] != '.') {
usti[num[i][j]] = tmp, tmp = num[i][j];
}
}
tmp = -1;
for (int i = n; i >= 1; i--) {
if (a[i][j] != '.') {
asti[num[i][j]] = tmp, tmp = num[i][j];
}
}
}
int mx = 0;
int res = 0;
for (int i = 1; i <= K; i++) {
for (int j = 1; j <= K; j++) {
SOLI[j] = soli[j], ONNI[j] = onni[j], USTI[j] = usti[j],
ASTI[j] = asti[j];
}
int cnt = 0;
for (int z = i, j; z != -1; z = j) {
if (letter[z] == 'L') j = SOLI[z];
if (letter[z] == 'R') j = ONNI[z];
if (letter[z] == 'U') j = USTI[z];
if (letter[z] == 'D') j = ASTI[z];
if (ONNI[z] != -1) SOLI[ONNI[z]] = SOLI[z];
if (SOLI[z] != -1) ONNI[SOLI[z]] = ONNI[z];
if (USTI[z] != -1) ASTI[USTI[z]] = ASTI[z];
if (ASTI[z] != -1) USTI[ASTI[z]] = USTI[z];
cnt++;
}
if (cnt > mx) mx = cnt, res = 0;
if (cnt == mx) res++;
}
cout << mx << ' ' << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int f[4][15111 + 1];
char Board[15111 + 1];
int getx[15111];
int gety[15111];
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
int trans(int x, int y) { return x * (m + 2) + y; }
int outBoard(int x, int y) { return (x < 1 || y < 1 || x > n || y > m); }
int getdir(int x, int y) {
if (Board[trans(x, y)] == 'L') return 0;
if (Board[trans(x, y)] == 'R') return 1;
if (Board[trans(x, y)] == 'D') return 2;
if (Board[trans(x, y)] == 'U') return 3;
return -1;
}
int getf(int dir, int w) {
return f[dir][w] == w ? w : f[dir][w] = getf(dir, f[dir][w]);
}
void delit(int x, int y) {
int id = trans(x, y);
for (int i = 0; i < 4; i++) f[i][id] = trans(x + dx[i], y + dy[i]);
}
int solve(int x, int y) {
for (int i = 0; i < 15111; i++)
for (int j = 0; j < 4; j++) f[j][i] = i;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (Board[trans(i, j)] == '.') delit(i, j);
delit(x, y);
int ret = 0;
while (1) {
if (outBoard(x, y)) break;
ret++;
int dir = getdir(x, y);
int cur = trans(x + dx[dir], y + dy[dir]);
cur = getf(dir, cur);
x = getx[cur];
y = gety[cur];
delit(x, y);
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n >> m) {
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++) {
getx[trans(i, j)] = i;
gety[trans(i, j)] = j;
}
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
s = " " + s;
for (int j = 1; j <= m; j++) Board[trans(i, j)] = s[j];
}
int MAXANS = 0, CNT = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (Board[trans(i, j)] != '.') {
int t = solve(i, j);
if (t > MAXANS) MAXANS = t, CNT = 0;
if (t == MAXANS) {
CNT++;
}
}
cout << MAXANS << " " << CNT << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ni() {
int a;
scanf("%d", &a);
return a;
}
double nf() {
double a;
scanf("%lf", &a);
return a;
}
char sbuf[100005];
string ns() {
scanf("%s", sbuf);
return sbuf;
}
long long nll() {
long long a;
scanf("%lld", &a);
return a;
}
template <class T>
void out(T a, T b) {
bool first = true;
for (T i = a; i != b; ++i) {
if (!first) printf(" ");
first = false;
cout << *i;
}
printf("\n");
}
template <class T>
void outl(T a, T b) {
for (T i = a; i != b; ++i) {
cout << *i << "\n";
}
}
int n, m;
vector<string> f;
int ans = -1, ansn;
short nx[5001][5001][5];
int doIt(int y, int x) {
int dir = -1;
if (f[y][x] == 'U')
dir = 0;
else if (f[y][x] == 'D')
dir = 1;
else if (f[y][x] == 'L')
dir = 2;
else if (f[y][x] == 'R')
dir = 3;
else
assert(false);
int xx = x, yy = y;
while (true) {
xx = x, yy = y;
if (dir < 2)
yy = nx[y][x][dir];
else
xx = nx[y][x][dir];
if (xx == -1 || yy == -1) return 1;
if (nx[yy][xx][4]) {
nx[y][x][dir] = nx[yy][xx][dir];
continue;
}
nx[y][x][4] = 1;
break;
}
return doIt(yy, xx) + 1;
}
int main() {
int i, j, k;
n = ni();
m = ni();
for (i = (0); i < (((n))); ++i) f.push_back(ns());
int ii, jj;
for (ii = (0); ii < ((n)); ++ii)
for (jj = (0); jj < ((m)); ++jj)
if (f[ii][jj] != '.') {
for (i = (0); i < (((n))); ++i)
for (j = (0); j < (((m))); ++j) nx[i][j][4] = 0;
for (i = (0); i < (((n))); ++i) {
int ls = -1;
for (j = (0); j < (((m))); ++j) {
nx[i][j][2] = ls;
if (f[i][j] != '.') ls = j;
}
ls = -1;
for (j = m - 1; j >= 0; --j) {
nx[i][j][3] = ls;
if (f[i][j] != '.') ls = j;
}
}
for (j = (0); j < (((m))); ++j) {
int ls = -1;
for (i = (0); i < (((n))); ++i) {
nx[i][j][0] = ls;
if (f[i][j] != '.') ls = i;
}
ls = -1;
for (i = n - 1; i >= 0; --i) {
nx[i][j][1] = ls;
if (f[i][j] != '.') ls = i;
}
}
int cur = doIt(ii, jj);
if (cur > ans) {
ans = cur;
ansn = 1;
} else if (cur == ans)
++ansn;
}
printf("%d %d\n", ans, ansn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 5e3 + 5;
short leftt[N][N], rightt[N][N], up[N][N], down[N][N];
string arr[N];
void compute() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
leftt[i][j] = up[i][j] = down[i][j] = rightt[i][j] = -1;
if (arr[i][j] != '.') {
int x = i - 1;
while (x >= 0) {
if (arr[x][j] != '.') {
up[i][j] = x;
break;
}
x--;
}
x = i + 1;
while (x < n) {
if (arr[x][j] != '.') {
down[i][j] = x;
break;
}
x++;
}
int y = j - 1;
while (y >= 0) {
if (arr[i][y] != '.') {
leftt[i][j] = y;
break;
}
y--;
}
y = j + 1;
while (y < m) {
if (arr[i][y] != '.') {
rightt[i][j] = y;
break;
}
y++;
}
}
}
}
}
void remove(int r, int c) {
if (up[r][c] >= 0) {
int rr = up[r][c];
down[rr][c] = down[r][c];
}
if (leftt[r][c] >= 0) {
int cc = leftt[r][c];
rightt[r][cc] = rightt[r][c];
}
if (down[r][c] >= 0) {
int rr = down[r][c];
up[rr][c] = up[r][c];
}
if (rightt[r][c] >= 0) {
int cc = rightt[r][c];
leftt[r][cc] = leftt[r][c];
}
}
int find(int r, int c) {
int ret = 0;
int pr = r, pc = c;
while (pr >= 0 && pc >= 0) {
ret++;
remove(pr, pc);
if (arr[pr][pc] == 'D')
pr = down[pr][pc];
else if (arr[pr][pc] == 'R')
pc = rightt[pr][pc];
else if (arr[pr][pc] == 'U')
pr = up[pr][pc];
else
pc = leftt[pr][pc];
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> arr[i];
int mx = 0, cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
compute();
if (arr[i][j] != '.') {
int val = find(i, j);
if (val > mx) {
mx = val;
cnt = 1;
} else if (mx == val)
cnt++;
}
}
}
cout << mx << " " << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool uax(T &x, T y) {
return (y > x) ? x = y, true : false;
}
template <typename T>
inline bool uin(T &x, T y) {
return (y < x) ? x = y, true : false;
}
template <typename T>
void kek(T ans) {
cout << ans << endl;
exit(0);
}
const int MOD = (int)1e9 + 7;
const long long INF = (long long)1e18 + 42;
int dir[512];
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
dir['L'] = 0, dir['R'] = 1, dir['U'] = 2, dir['D'] = 3;
int n, m;
cin >> n >> m;
vector<string> a(n);
for (auto &s : a) cin >> s;
vector<array<int, 4> > cells(n * m);
for (int i = 0; i < n; ++i) {
int p = -1;
for (int j = 0; j < m; ++j) {
cells[i * m + j][0] = p;
if (a[i][j] != '.') p = i * m + j;
}
p = -1;
for (int j = m - 1; j >= 0; --j) {
cells[i * m + j][1] = p;
if (a[i][j] != '.') p = i * m + j;
}
}
for (int j = 0; j < m; ++j) {
int p = -1;
for (int i = 0; i < n; ++i) {
cells[i * m + j][2] = p;
if (a[i][j] != '.') p = i * m + j;
}
p = -1;
for (int i = n - 1; i >= 0; --i) {
cells[i * m + j][3] = p;
if (a[i][j] != '.') p = i * m + j;
}
}
int ans = 0, cnt = n * m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j)
if (a[i][j] != '.') {
auto cp = cells;
int cur = 0;
int c = i * m + j;
while (~c) {
++cur;
for (int d = 0; d < 4; ++d)
if (~cells[c][d]) cells[cells[c][d]][d ^ 1] = cells[c][d ^ 1];
c = cells[c][dir[a[c / m][c % m]]];
}
if (uax(ans, cur)) cnt = 0;
cnt += ans == cur;
swap(cp, cells);
}
}
cout << ans << ' ' << cnt << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 5005;
vector<string> g;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
vector<int> Set[4][MaxN];
int Get(char c) {
if (c == 'R') return 0;
if (c == 'D') return 1;
if (c == 'L') return 2;
return 3;
}
int n, m;
bool check(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m) return 0;
return 1;
}
char s[MaxN];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
string t = s;
g.push_back(t);
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++) Set[k][i].push_back(0);
}
int ret = 0, a = 0;
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++)
if (g[x][y] != '.') {
for (int i = 0; i < n; i++) {
int p = -1;
for (int j = 0; j < m; j++)
if (g[i][j] != '.') {
Set[2][i][j] = p;
p = j;
}
}
for (int i = 0; i < n; i++) {
int p = m;
for (int j = m - 1; j >= 0; j--)
if (g[i][j] != '.') {
Set[0][i][j] = p;
p = j;
}
}
for (int i = 0; i < m; i++) {
int p = -1;
for (int j = 0; j < n; j++)
if (g[j][i] != '.') {
Set[3][j][i] = p;
p = j;
}
}
for (int i = 0; i < m; i++) {
int p = n;
for (int j = n - 1; j >= 0; j--)
if (g[j][i] != '.') {
Set[1][j][i] = p;
p = j;
}
}
int nx = x, ny = y, ct = 1;
while (1) {
int d = Get(g[nx][ny]);
int xx, yy;
if (d == 0 || d == 2)
xx = nx, yy = Set[d][nx][ny];
else
yy = ny, xx = Set[d][nx][ny];
if (!check(xx, yy)) break;
int tx[4], ty[4];
for (d = 0; d < 4; d++) {
if (d == 0 || d == 2)
tx[d] = nx, ty[d] = Set[d][nx][ny];
else
ty[d] = ny, tx[d] = Set[d][nx][ny];
}
for (d = 0; d < 4; d++)
if (check(tx[d], ty[d])) {
Set[(d + 2) % 4][tx[d]][ty[d]] =
((d == 0 || d == 2) ? ty[(d + 2) % 4] : tx[(d + 2) % 4]);
}
ct++;
nx = xx, ny = yy;
}
if (ret < ct) {
ret = ct;
a = 1;
} else if (ret == ct)
a++;
}
printf("%d %d\n", ret, a);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct NODE {
char c;
NODE *l, *r, *u, *d;
NODE(char C) {
c = C;
u = d = l = r = (NODE *)0;
}
};
int f(NODE *pos) {
if (pos == NULL) return 0;
int ans;
NODE *l = pos->l, *r = pos->r, *u = pos->u, *d = pos->d;
if (l) l->r = r;
if (r) r->l = l;
if (u) u->d = d;
if (d) d->u = u;
if (pos->c == 'U')
ans = f(pos->u) + 1;
else if (pos->c == 'D')
ans = f(pos->d) + 1;
else if (pos->c == 'L')
ans = f(pos->l) + 1;
else if (pos->c == 'R')
ans = f(pos->r) + 1;
if (l) l->r = pos;
if (r) r->l = pos;
if (u) u->d = pos;
if (d) d->u = pos;
return ans;
}
int main() {
int H, W;
char c;
cin >> H >> W;
vector<vector<NODE *> > memo(H, vector<NODE *>(W, (NODE *)0));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> c;
if (c != '.') memo[i][j] = new NODE(c);
}
}
for (int i = 0; i < H; i++) {
NODE *prev = (NODE *)0;
for (int j = 0; j < W; j++) {
if (memo[i][j] != NULL) {
memo[i][j]->l = prev;
if (prev != NULL) prev->r = memo[i][j];
prev = memo[i][j];
}
}
prev = (NODE *)0;
for (int j = W - 1; j >= 0; j--) {
if (memo[i][j] != NULL) {
memo[i][j]->r = prev;
if (prev != NULL) prev->l = memo[i][j];
prev = memo[i][j];
}
}
}
for (int j = 0; j < W; j++) {
NODE *prev = (NODE *)0;
for (int i = 0; i < H; i++) {
if (memo[i][j] != NULL) {
memo[i][j]->u = prev;
if (prev != NULL) prev->d = memo[i][j];
prev = memo[i][j];
}
}
prev = (NODE *)0;
for (int i = H - 1; i >= 0; i--) {
if (memo[i][j] != NULL) {
memo[i][j]->d = prev;
if (prev != NULL) prev->u = memo[i][j];
prev = memo[i][j];
}
}
}
int ans = 0, cnt = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
int g = f(memo[i][j]);
if (ans == g) {
cnt++;
} else if (g > ans) {
cnt = 1;
ans = g;
}
}
}
cout << ans << " " << cnt << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
node *u, *d, *l, *r;
int x, y;
node() {
u = NULL;
d = NULL;
l = NULL;
r = NULL;
}
};
vector<vector<node> > arr;
vector<string> in;
int n, m;
void calcr(int x) {
node *curr = NULL;
for (int i = 0; i < m; ++i) {
if (in[x][i] == '.') continue;
arr[x][i].l = curr;
if (curr != NULL) curr->r = &arr[x][i];
curr = &arr[x][i];
}
}
void calcc(int x) {
node *curr = NULL;
for (int i = 0; i < n; ++i) {
if (in[i][x] == '.') continue;
arr[i][x].u = curr;
if (curr != NULL) curr->d = &arr[i][x];
curr = &arr[i][x];
}
}
int dfs(node *curr) {
int cx = curr->x, cy = curr->y, ret = 1;
node *nex;
if (in[cx][cy] == 'U') {
if (curr->u == NULL) return 1;
nex = curr->u;
} else if (in[cx][cy] == 'D') {
if (curr->d == NULL) return 1;
nex = curr->d;
} else if (in[cx][cy] == 'L') {
if (curr->l == NULL) return 1;
nex = curr->l;
} else if (in[cx][cy] == 'R') {
if (curr->r == NULL) return 1;
nex = curr->r;
}
node *u = curr->u, *d = curr->d, *l = curr->l, *r = curr->r;
if (l != NULL) l->r = r;
if (r != NULL) r->l = l;
if (u != NULL) u->d = d;
if (d != NULL) d->u = u;
ret += dfs(nex);
if (l != NULL) l->r = curr;
if (r != NULL) r->l = curr;
if (u != NULL) u->d = curr;
if (d != NULL) d->u = curr;
return ret;
}
int main() {
cin >> n >> m;
in.resize(n);
arr.resize(n);
for (int i = 0; i < n; ++i) {
cin >> in[i];
arr[i].resize(m);
for (int j = 0; j < m; ++j) arr[i][j].x = i, arr[i][j].y = j;
}
for (int i = 0; i < n; ++i) calcr(i);
for (int i = 0; i < m; ++i) calcc(i);
int ans = 0, c = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (in[i][j] == '.') continue;
int ret = dfs(&arr[i][j]);
if (ret == ans) c++;
if (ret > ans) {
ans = ret;
c = 1;
}
}
}
cout << ans << " " << c;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
map<char, int> Z;
int E[5010][5010], Q[5010];
int U[5010], D[5010], L[5010], R[5010];
char ss[5010];
int dfs(int mm) {
int nn;
if (mm == 0) return 0;
if (Q[mm] == 1)
nn = U[mm];
else if (Q[mm] == 2)
nn = D[mm];
else if (Q[mm] == 3)
nn = L[mm];
else if (Q[mm] == 4)
nn = R[mm];
if (L[mm] != 0) R[L[mm]] = R[mm];
if (R[mm] != 0) L[R[mm]] = L[mm];
if (D[mm] != 0) U[D[mm]] = U[mm];
if (U[mm] != 0) D[U[mm]] = D[mm];
int res = dfs(nn);
if (L[mm] != 0) R[L[mm]] = mm;
if (R[mm] != 0) L[R[mm]] = mm;
if (D[mm] != 0) U[D[mm]] = mm;
if (U[mm] != 0) D[U[mm]] = mm;
return res + 1;
}
int main() {
Z['U'] = 1, Z['D'] = 2, Z['L'] = 3, Z['R'] = 4, Z['.'] = 0;
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%s", ss + 1);
for (int j = 1; j <= M; j++) {
E[i][j] = Z[ss[j]];
Q[(i - 1) * M + j] = E[i][j];
}
}
memset(U, 0, sizeof(U));
memset(D, 0, sizeof(D));
memset(L, 0, sizeof(L));
memset(R, 0, sizeof(R));
for (int i = 1; i <= N; i++) {
int ll = 0, mm;
for (int j = 1; j <= M; j++)
if (E[i][j] != 0) {
mm = (i - 1) * M + j;
if (ll != 0) L[mm] = ll, R[ll] = mm;
ll = mm;
}
}
for (int j = 1; j <= M; j++) {
int uu = 0, mm;
for (int i = 1; i <= N; i++)
if (E[i][j] != 0) {
mm = (i - 1) * M + j;
if (uu != 0) U[mm] = uu, D[uu] = mm;
uu = mm;
}
}
int mx = 0, cnt;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
if (E[i][j] != 0) {
int k = dfs((i - 1) * M + j);
if (k > mx)
mx = k, cnt = 1;
else if (k == mx)
cnt++;
}
cout << mx << " " << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, y, z, now, ans, dp[5005], l[5005], r[5005], u[5005], d[5005],
lh[5005], rh[5005], uh[5005], dh[5005];
char a[5005], c;
void dsu(long long x) {
if (a[x] == 'U' && !uh[x]) {
return;
}
if (a[x] == 'D' && !dh[x]) {
return;
}
if (a[x] == 'R' && !rh[x]) {
return;
}
if (a[x] == 'L' && !lh[x]) {
return;
}
ans++;
y = lh[x], z = rh[x];
rh[y] = z, lh[z] = y;
y = uh[x], z = dh[x];
dh[y] = z, uh[z] = y;
if (a[x] == 'U') {
dsu(uh[x]);
} else if (a[x] == 'R') {
dsu(rh[x]);
} else if (a[x] == 'L') {
dsu(lh[x]);
} else if (a[x] == 'D') {
dsu(dh[x]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c;
a[(i - 1) * m + j] = c;
}
}
for (int i = 1; i <= m; i++) {
now = 0;
for (int j = 1; j <= n; j++) {
if (a[(j - 1) * m + i] == '.') {
continue;
}
d[now] = (j - 1) * m + i;
u[(j - 1) * m + i] = now;
now = (j - 1) * m + i;
}
d[now] = 0;
}
for (int i = 1; i <= n; i++) {
now = 0;
for (int j = 1; j <= m; j++) {
if (a[(i - 1) * m + j] == '.') {
continue;
}
r[now] = (i - 1) * m + j;
l[(i - 1) * m + j] = now;
now = (i - 1) * m + j;
}
r[now] = 0;
}
for (int i = 1; i <= n; i++) {
for (int q = 1; q <= m; q++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= m; k++) {
lh[(j - 1) * m + k] = l[(j - 1) * m + k];
rh[(j - 1) * m + k] = r[(j - 1) * m + k];
uh[(j - 1) * m + k] = u[(j - 1) * m + k];
dh[(j - 1) * m + k] = d[(j - 1) * m + k];
}
}
ans = 1;
if (a[(i - 1) * m + q] != '.') {
dsu((i - 1) * m + q);
dp[ans]++;
}
}
}
for (int i = 5000; i >= 1; i--) {
if (dp[i]) {
cout << i << " " << dp[i] << '\n';
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 10;
short int RowNext[maxn][maxn], RowPrev[maxn][maxn], ColNext[maxn][maxn],
ColPrev[maxn][maxn], n, m;
char c[maxn][maxn];
void makeLinks() {
for (int r = 1; r <= n; r++) {
int pr = 0;
for (int i = 1; i <= m; i++) {
RowPrev[r][i] = pr;
if (c[r][i] != '.' && pr != 0) RowNext[r][pr] = i;
if (c[r][i] != '.') pr = i;
}
}
for (int col = 1; col <= m; col++) {
int pr = 0;
for (int i = 1; i <= n; i++) {
ColPrev[col][i] = pr;
if (c[i][col] != '.' && pr != 0) ColNext[col][pr] = i;
if (c[i][col] != '.') pr = i;
}
}
}
pair<int, int> neX(int i, int j) {
if (c[i][j] == 'R') {
if (RowNext[i][j] == 0) return make_pair(0, 0);
return make_pair(i, RowNext[i][j]);
}
if (c[i][j] == 'L') {
if (RowPrev[i][j] == 0) return make_pair(0, 0);
return make_pair(i, RowPrev[i][j]);
}
if (c[i][j] == 'D') {
if (ColNext[j][i] == 0) return make_pair(0, 0);
return make_pair(ColNext[j][i], j);
}
if (c[i][j] == 'U') {
if (ColPrev[j][i] == 0) return make_pair(0, 0);
return make_pair(ColPrev[j][i], j);
}
}
void del(int i, int j) {
if (RowNext[i][j] != 0 && RowPrev[i][j] != 0) {
RowNext[i][RowPrev[i][j]] = RowNext[i][j];
RowPrev[i][RowNext[i][j]] = RowPrev[i][j];
} else if (RowNext[i][j] != 0) {
RowPrev[i][RowNext[i][j]] = 0;
} else if (RowPrev[i][j] != 0) {
RowNext[i][RowPrev[i][j]] = 0;
}
if (ColNext[j][i] != 0 && ColPrev[j][i] != 0) {
ColNext[j][ColPrev[j][i]] = ColNext[j][i];
ColPrev[j][ColNext[j][i]] = ColPrev[j][i];
} else if (ColNext[j][i] != 0) {
ColPrev[j][ColNext[j][i]] = 0;
} else if (ColPrev[j][i] != 0) {
ColNext[j][ColPrev[j][i]] = 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
int Ans = 0, maxx = -10000;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> c[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (c[i][j] == '.') continue;
makeLinks();
int x = i, y = j, ans = 0;
while (true) {
ans++;
if (neX(x, y).first == 0) break;
pair<int, int> X = neX(x, y);
del(x, y);
x = X.first, y = X.second;
}
if (ans > maxx)
Ans = 1, maxx = ans;
else if (ans == maxx)
Ans++;
}
cout << maxx << " " << Ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct chip {
char dir;
chip *u, *r, *d, *l;
chip(char _dir) {
dir = _dir;
u = r = d = l = NULL;
}
};
int main(int argc, char* argv[]) {
int n, m;
cin >> n >> m;
chip*** t;
t = (chip***)malloc(n * sizeof(chip**));
for (int i = 0; i < n; i++) t[i] = (chip**)malloc(m * sizeof(chip*));
char d;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> d;
if (d != '.') {
t[i][j] = new chip(d);
if (i > 0) {
int k = i - 1;
while ((k >= 0) && (t[k][j] == NULL)) k--;
if (k >= 0) {
t[k][j]->d = t[i][j];
t[i][j]->u = t[k][j];
}
}
if (j > 0) {
int k = j - 1;
while ((k >= 0) && (t[i][k] == NULL)) k--;
if (k >= 0) {
t[i][k]->r = t[i][j];
t[i][j]->l = t[i][k];
}
}
} else
t[i][j] = NULL;
}
}
int max = 0;
int count = 0;
vector<chip*> v;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v.clear();
chip* c = t[i][j];
while (c != NULL) {
v.push_back(c);
chip* e;
if (c->dir == 'U') e = c->u;
if (c->dir == 'R') e = c->r;
if (c->dir == 'D') e = c->d;
if (c->dir == 'L') e = c->l;
if (c->u != NULL) c->u->d = c->d;
if (c->r != NULL) c->r->l = c->l;
if (c->d != NULL) c->d->u = c->u;
if (c->l != NULL) c->l->r = c->r;
c = e;
}
if (v.size() > max) {
max = v.size();
count = 0;
}
if (v.size() == max) count++;
for (vector<chip*>::reverse_iterator r = v.rbegin(); r < v.rend(); r++) {
chip* e = *r;
if (e->u != NULL) e->u->d = e;
if (e->r != NULL) e->r->l = e;
if (e->d != NULL) e->d->u = e;
if (e->l != NULL) e->l->r = e;
}
}
}
cout << max << " " << count << endl;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) free(t[i][j]);
for (int i = 0; i < n; i++) free(t[i]);
free(t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[10005];
char chcp[10005];
int dpr[10005][4];
int dpc[10005][4];
int row, col;
int arah[2000];
int dr[] = {0, 1, 0, -1};
int dc[] = {1, 0, -1, 0};
char buffer[10500];
bool inside(int r, int c) { return r >= 0 && r < row && c >= 0 && c < col; }
pair<int, int> move(int r, int c, int arah) {
if (!inside(r, c)) return make_pair(r, c);
if (chcp[r * col + c] != '.') return make_pair(r, c);
if (dpr[r * col + c][arah] == -10) {
dpr[r * col + c][arah] = r + dr[arah];
dpc[r * col + c][arah] = c + dc[arah];
}
pair<int, int> hasil =
move(dpr[r * col + c][arah], dpc[r * col + c][arah], arah);
dpr[r * col + c][arah] = hasil.first;
dpc[r * col + c][arah] = hasil.second;
return hasil;
}
int main() {
arah['R'] = 0;
arah['D'] = 1;
arah['L'] = 2;
arah['U'] = 3;
scanf("%d%d\n", &row, &col);
int best = 0;
int ret = 0;
for (int(i) = 0; (i) < (row); ++(i)) {
scanf("%s\n", buffer);
for (int j = i * col; j < (i + 1) * col; ++j) ch[j] = buffer[j - i * col];
}
for (int(ir) = 0; (ir) < (row); ++(ir))
for (int(ic) = 0; (ic) < (col); ++(ic))
if (ch[ir * col + ic] != '.') {
for (int(r) = 0; (r) < (row * col); ++(r))
for (int(d) = 0; (d) < (4); ++(d)) dpr[r][d] = dpc[r][d] = -10;
for (int(r) = 0; (r) < (row * col); ++(r)) chcp[r] = ch[r];
int moves = 0;
int r = ir, c = ic;
while (inside(r, c)) {
++moves;
int a = arah[(int)chcp[r * col + c]];
chcp[r * col + c] = '.';
pair<int, int> p = move(r, c, a);
r = p.first;
c = p.second;
}
if (moves > best) {
best = moves;
ret = 0;
}
if (moves == best) ++ret;
}
cout << best << " " << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solvetask() {
int n, m;
cin >> n >> m;
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == '.')
a[i][j] = 0;
else if (c == 'U')
a[i][j] = 1;
else if (c == 'R')
a[i][j] = 2;
else if (c == 'D')
a[i][j] = 3;
else if (c == 'L')
a[i][j] = 4;
}
}
int nextd[n][m][5], next[n][m][5];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
nextd[i][j][0] = -1;
int ans = -1;
for (int ii = i - 1; ii >= 0; ii--)
if (a[ii][j]) {
ans = ii;
break;
}
nextd[i][j][1] = ans;
ans = -1;
for (int ii = i + 1; ii < n; ii++)
if (a[ii][j]) {
ans = ii;
break;
}
nextd[i][j][3] = ans;
ans = -1;
for (int jj = j + 1; jj < m; jj++)
if (a[i][jj]) {
ans = jj;
break;
}
nextd[i][j][2] = ans;
ans = -1;
for (int jj = j - 1; jj >= 0; jj--)
if (a[i][jj]) {
ans = jj;
break;
}
nextd[i][j][4] = ans;
}
}
int ans = 0, cnt = 0;
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < m; jj++) {
if (!a[ii][jj]) continue;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 5; k++) next[i][j][k] = nextd[i][j][k];
int i = ii, j = jj, cur = 1;
while (next[i][j][a[i][j]] != -1) {
cur++;
if (next[i][j][4] != -1) next[i][next[i][j][4]][2] = next[i][j][2];
if (next[i][j][2] != -1) next[i][next[i][j][2]][4] = next[i][j][4];
if (next[i][j][1] != -1) next[next[i][j][1]][j][3] = next[i][j][3];
if (next[i][j][3] != -1) next[next[i][j][3]][j][1] = next[i][j][1];
if (a[i][j] == 1 || a[i][j] == 3)
i = next[i][j][a[i][j]];
else
j = next[i][j][a[i][j]];
}
if (cur > ans) {
ans = cur;
cnt = 1;
} else if (cur == ans)
cnt++;
}
}
cout << ans << " " << cnt << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) solvetask();
}
|
#include <bits/stdc++.h>
short L[5005][5005], R[5005][5005], U[5005][5005], D[5005][5005];
char q[5005][5005];
int n, m, av, aw, sp;
void gao(int x, int y) {
if (x < 1 || y < 1 || x > m || y > n) return;
++sp;
L[x][R[x][y]] = L[x][y];
R[x][L[x][y]] = R[x][y];
U[D[x][y]][y] = U[x][y];
D[U[x][y]][y] = D[x][y];
switch (q[x][y]) {
case ('L'):
gao(x, L[x][y]);
break;
case ('R'):
gao(x, R[x][y]);
break;
case ('U'):
gao(U[x][y], y);
break;
default:
gao(D[x][y], y);
break;
}
L[x][R[x][y]] = y;
R[x][L[x][y]] = y;
U[D[x][y]][y] = x;
D[U[x][y]][y] = x;
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= m; i++) scanf("%s", q[i] + 1);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++)
L[i][j] = q[i][j - 1] != '.' ? j - 1 : L[i][j - 1];
for (int j = n; j > 0; j--)
R[i][j] = q[i][j + 1] != '.' ? j + 1 : R[i][j + 1];
}
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= m; i++)
U[i][j] = q[i - 1][j] != '.' ? i - 1 : U[i - 1][j];
for (int i = m; i > 0; i--)
D[i][j] = q[i + 1][j] != '.' ? i + 1 : D[i + 1][j];
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (q[i][j] != '.') {
sp = 0;
gao(i, j);
if (sp == av)
++aw;
else if (sp > av)
av = sp, aw = 1;
}
printf("%d %d\n", av, aw);
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, mn, ans, cnt, p[5005][4];
char c[5005];
int v[5005], vw;
int f(char c) {
switch (c) {
case 'L':
return 0;
case 'R':
return 1;
case 'U':
return 2;
case 'D':
return 3;
}
}
int solve(int x) {
for (int i = 0; i < mn; ++i) {
p[i][0] = i % n == 0 ? -1 : i - 1;
p[i][1] = i % n == n - 1 ? -1 : i + 1;
p[i][2] = i - n;
p[i][3] = i + n;
}
vw = x;
int ret = 0;
while (1) {
ret++;
v[x] = vw;
int z = f(c[x]);
int X = x;
while (c[X] == '.' || v[X] == vw) {
X = p[X][z];
if (!(0 <= X && X < mn)) return ret;
}
p[x][z] = X;
x = X;
}
}
int main() {
scanf("%d%d", &m, &n);
mn = m * n;
for (int i = 0; i < m; ++i) scanf("%s", c + i * n);
memset(v, -1, sizeof(v));
ans = cnt = 0;
for (int i = 0; i < mn; ++i) {
if (c[i] != '.') {
int tmp = solve(i);
if (tmp > ans) {
ans = tmp;
cnt = 1;
} else if (tmp == ans)
cnt++;
}
}
printf("%d %d\n", ans, cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int SG(double x) { return x > -1E-8 ? x < 1E-8 ? 0 : 1 : -1; }
string str[6000];
int h[6000];
vector<int> L[6000];
vector<int> R[6000];
vector<int> D[6000];
vector<int> U[6000];
int maxd, dct;
inline void K(int x, int y) {
if (R[x][y] != -1) L[x][R[x][y]] = L[x][y];
if (L[x][y] != -1) R[x][L[x][y]] = R[x][y];
if (U[x][y] != -1) D[U[x][y]][y] = D[x][y];
if (D[x][y] != -1) U[D[x][y]][y] = U[x][y];
}
inline void H(int x, int y) {
if (R[x][y] != -1) L[x][R[x][y]] = y;
if (L[x][y] != -1) R[x][L[x][y]] = y;
if (U[x][y] != -1) D[U[x][y]][y] = x;
if (D[x][y] != -1) U[D[x][y]][y] = x;
}
void dfs(int x, int y, int d) {
if (x == -1 || y == -1) {
if (d > maxd) {
maxd = d;
dct = 1;
} else if (d == maxd) {
dct++;
}
return;
}
K(x, y);
if (str[x][y] == 'L') {
dfs(x, L[x][y], d + 1);
} else if (str[x][y] == 'R') {
dfs(x, R[x][y], d + 1);
} else if (str[x][y] == 'D') {
dfs(D[x][y], y, d + 1);
} else {
dfs(U[x][y], y, d + 1);
}
H(x, y);
}
int main() {
int n, m, i, j, k;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
cin >> str[i];
}
for (j = 0; j < m; j++) {
h[j] = -1;
}
for (i = 0; i < n; i++) {
L[i].resize(m);
R[i].resize(m);
D[i].resize(m);
U[i].resize(m);
}
for (i = 0; i < n; i++) {
k = -1;
for (j = 0; j < m; j++) {
if (str[i][j] != '.') {
L[i][j] = k;
if (k != -1) R[i][k] = j;
U[i][j] = h[j];
if (h[j] != -1) D[h[j]][j] = i;
k = j;
h[j] = i;
}
}
if (k != -1) R[i][k] = -1;
}
for (j = 0; j < m; j++) {
if (h[j] != -1) D[h[j]][j] = -1;
}
maxd = -1;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (str[i][j] != '.') {
dfs(i, j, 0);
}
}
}
printf("%d %d\n", maxd, dct);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long labs(long long a) { return a < 0 ? (-a) : a; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
template <typename T>
struct Point {
T x, y;
Point() {}
Point(T xx, T yy) : x(xx), y(yy) {}
};
template <typename T>
bool operator<(const Point<T> &p1, const Point<T> &p2) {
return p1.x < p2.x || p1.x == p2.x && p1.y < p2.y;
}
vector<vector<short> > mas, lm, rm, um, dm;
vector<vector<short> > mas0, lm0, rm0, um0, dm0;
vector<vector<vector<short> > *> v, v0;
short n, m;
const short LEFT = 1, RIGHT = 2, UP = 3, DOWN = 4, EMPTY = 0;
void CalcRight() {
for (int(i) = 0; (i) < (n); (i)++) {
short last = m;
for (int(j) = (m)-1; (j) >= 0; (j)--) {
rm0[i][j] = last;
if (mas0[i][j] != EMPTY) last = j;
}
}
}
void CalcDown() {
for (int(j) = 0; (j) < (m); (j)++) {
short last = n;
for (int(i) = (n)-1; (i) >= 0; (i)--) {
dm0[i][j] = last;
if (mas0[i][j] != EMPTY) last = i;
}
}
}
void CalcUp() {
for (int(j) = 0; (j) < (m); (j)++) {
short last = -1;
for (int(i) = 0; (i) < (n); (i)++) {
um0[i][j] = last;
if (mas0[i][j] != EMPTY) last = i;
}
}
}
void CalcLeft() {
for (int(i) = 0; (i) < (n); (i)++) {
short last = -1;
for (int(j) = 0; (j) < (m); (j)++) {
lm0[i][j] = last;
if (mas0[i][j] != EMPTY) last = j;
}
}
}
void Calc() {
CalcLeft();
CalcRight();
CalcUp();
CalcDown();
}
void Copy() {
for (int(i) = 0; (i) < (v.size()); (i)++) {
(*v[i]) = (*v0[i]);
}
}
bool IsInBorder(short i, short j) { return i >= 0 && j >= 0 && i < n && j < m; }
short Go(short i, short j, short mode) {
if (mode == LEFT || mode == RIGHT) {
if (!IsInBorder(i, j) || mas[i][j] != EMPTY) return j;
(*v[mode])[i][j] = Go(i, (*v[mode])[i][j], mode);
return (*v[mode])[i][j];
} else {
if (!IsInBorder(i, j) || mas[i][j] != EMPTY) return i;
(*v[mode])[i][j] = Go((*v[mode])[i][j], j, mode);
return (*v[mode])[i][j];
}
}
int main() {
cin >> n >> m;
v.push_back(&mas);
v.push_back(&lm);
v.push_back(&rm);
v.push_back(&um);
v.push_back(&dm);
v0.push_back(&mas0);
v0.push_back(&lm0);
v0.push_back(&rm0);
v0.push_back(&um0);
v0.push_back(&dm0);
for (int(i) = 0; (i) < (v0.size()); (i)++) {
v0[i]->resize(n, vector<short>(m));
}
char c;
for (int(i) = 0; (i) < (n); (i)++) {
for (int(j) = 0; (j) < (m); (j)++) {
cin >> c;
switch (c) {
case 'L':
mas0[i][j] = LEFT;
break;
case 'R':
mas0[i][j] = RIGHT;
break;
case 'U':
mas0[i][j] = UP;
break;
case 'D':
mas0[i][j] = DOWN;
break;
default:
mas0[i][j] = EMPTY;
}
}
}
Calc();
short bestl = 0;
short bestcnt = 0;
short a, b, l, mode;
for (int(i) = 0; (i) < (n); (i)++) {
for (int(j) = 0; (j) < (m); (j)++) {
if (mas0[i][j] == EMPTY) continue;
Copy();
a = i;
b = j;
l = 0;
while (IsInBorder(a, b)) {
l++;
mode = mas[a][b];
mas[a][b] = EMPTY;
if (mode == LEFT || mode == RIGHT) {
b = Go(a, b, mode);
} else {
a = Go(a, b, mode);
}
}
if (l > bestl) {
bestl = l;
bestcnt = 1;
} else if (l == bestl) {
bestcnt++;
}
}
}
cout << bestl << " " << bestcnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
set<int> g[N], disconn;
vector<int> ans_vec, temp, temper;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int x, y;
while (m--) {
cin >> x >> y;
g[x].insert(y);
g[y].insert(x);
}
vector<int> v;
for (int i = 2; i <= n; i++) {
v.push_back(i);
}
set<int>::iterator it;
for (it = g[1].begin(); it != g[1].end(); it++) {
disconn.insert(*it);
}
int sz = n;
while (!v.empty()) {
for (int i = 0; i < v.size() && !disconn.empty(); i++) {
x = v[i];
if (disconn.find(x) != disconn.end()) {
continue;
} else {
for (it = disconn.begin(); it != disconn.end(); it++) {
if (g[x].find(*it) == g[x].end()) {
temp.push_back(*it);
}
}
for (int j = 0; j < temp.size(); j++) {
disconn.erase(temp[j]);
}
}
}
for (int i = 0; i < temp.size(); i++) {
x = temp[i];
for (it = disconn.begin(); it != disconn.end(); it++) {
if (g[x].find(*it) == g[x].end()) {
temper.push_back(*it);
}
}
for (int j = 0; j < temper.size(); j++) {
disconn.erase(temper[j]);
}
if (i == temp.size() - 1) {
temp.clear();
for (int j = 0; j < temper.size(); j++) {
temp.push_back(temper[j]);
}
if (!temp.empty()) {
i = -1;
}
temper.clear();
}
}
ans_vec.push_back(sz - disconn.size());
sz = disconn.size();
v.clear();
for (it = disconn.begin(); it != disconn.end(); it++) {
v.push_back(*it);
}
it = disconn.begin();
disconn.erase(*it);
}
sort(ans_vec.begin(), ans_vec.end());
cout << ans_vec.size() << "\n";
for (int i = 0; i < ans_vec.size(); i++) {
cout << ans_vec[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, u, v, cnt;
set<long long> adj[300005], rem;
set<long long>::iterator it;
vector<long long> ans;
void dfs(long long node) {
rem.erase(node);
cnt++;
for (it = rem.begin(); it != rem.end();) {
if (adj[node].count(*it)) {
it++;
continue;
}
long long tmp = *it;
dfs(tmp);
it = rem.lower_bound(tmp);
}
adj[node].clear();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
for (long long i = 1; i <= n; i++) rem.insert(i);
for (long long i = 1; i <= n; i++) {
if (rem.count(i)) {
cnt = 0;
dfs(i);
ans.push_back(cnt);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (auto x : ans) cout << x << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const double PI = acos(-1.0);
const double EPS = 1e-9;
const unsigned long long mod = 1000000007;
const unsigned long long INF = 1e9;
const unsigned long long LINF = 1e15;
const unsigned long long MAX = 3e5 + 7;
const unsigned long long MAXN = 1e6 + 1;
int n;
int m;
vector<set<int>> g;
set<int> unused;
vector<int> ans;
int cnt = 0;
void dfs(int v) {
unused.erase(v);
++cnt;
int go = -1;
while (1) {
auto it = unused.upper_bound(go);
if (it == unused.end()) return;
go = *it;
if (!g[v].count(go)) dfs(go);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
int u, v;
g.resize(n);
for (int i = (0); i < (m); ++i) {
cin >> u >> v;
--u;
--v;
g[v].insert(u);
g[u].insert(v);
}
for (int i = (0); i < (n); ++i) unused.insert(i);
for (int i = (0); i < (n); ++i) {
if (unused.count(i)) {
dfs(i);
ans.push_back(cnt);
cnt = 0;
}
}
sort(ans.begin(), ans.end());
cout << (int)((ans).size()) << endl;
for (auto i : ans) cout << i << " ";
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, bool> mp[300000];
vector<int> q, ans;
int n, m, l[300000], x;
char s[3000000];
int read() {
int p = 0, q = 1;
char ch = getchar();
while (s[x] < '0' || s[x] > '9') x++;
while (s[x] >= '0' && s[x] <= '9') p = p * 10 + s[x++] - '0';
return p * q;
}
int bfs(int u) {
int le = 0, ri = 1, size = q.size();
l[1] = u;
while (le < ri) {
int v = l[++le];
for (int j = 0; j < size; j++)
if (!mp[v][q[j]]) {
l[++ri] = q[j];
q[j--] = q[--size];
q.pop_back();
}
}
return ri;
}
int main() {
fread(s, 1, 3000000, stdin);
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
mp[u][v] = 1;
mp[v][u] = 1;
}
for (int i = 1; i <= n; i++) q.push_back(i);
while (!q.empty()) {
int v = q.back();
q.pop_back();
ans.push_back(bfs(v));
}
int cnt = ans.size();
sort(ans.begin(), ans.end());
cout << cnt << endl;
for (int i = 0; i < cnt; i++) printf("%d ", ans[i]);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
map<int, int> G[maxn];
vector<int> ans;
set<int> s;
inline void dfs(int u) {
vector<int> tmp;
for (int v : s)
if (G[u].find(v) == G[u].end()) tmp.push_back(v);
for (int x : tmp) s.erase(x);
for (int v : tmp) dfs(v);
}
int n, m;
int main() {
cin >> n >> m;
for (int u, v, i = 1; i <= m; i++) cin >> u >> v, G[u][v] = G[v][u] = 1;
for (int i = 1; i <= n; i++) s.insert(i);
while (!s.empty()) {
int u = *s.begin();
int pre = s.size();
dfs(u);
ans.push_back(pre - s.size());
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int x : ans) cout << x << " ";
return 0 ^ 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void INPUT() {}
const int N = 200005;
set<int> s;
map<pair<int, int>, bool> h;
int tot, n, x, y, m;
void dfs(int node) {
tot++;
s.erase(node);
set<int>::iterator it = s.begin();
int id;
while (it != s.end()) {
id = *it;
if (!h.count(make_pair(node, id))) {
dfs(id);
it = s.upper_bound(id);
} else
it++;
}
}
void solve() {
cin >> n >> m;
h.clear();
s.clear();
while (m--) {
cin >> x >> y;
x--;
y--;
h[make_pair(x, y)] = 1;
h[make_pair(y, x)] = 1;
}
for (int i = 0; i <= n - 1; i++) s.insert(i);
vector<int> ans;
int node;
while (!s.empty()) {
node = *(s.begin());
tot = 0;
dfs(node);
ans.push_back(tot);
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto &i : ans) cout << i << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
INPUT();
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 17;
set<int> rem;
set<int> G[MAXN];
int big;
void dfs(int u) {
rem.erase(u);
big++;
set<int>::iterator it = rem.begin();
while (it != rem.end()) {
int v = *it;
if (G[u].find(v) == G[u].end()) {
dfs(v);
it = rem.begin();
} else
it++;
}
}
vector<int> ans;
int main(int argc, char const *argv[]) {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
G[u].insert(v);
G[v].insert(u);
}
for (int i = 0; i < n; ++i) rem.insert(i);
while (!rem.empty()) {
int u = *rem.begin();
big = 0;
dfs(u);
ans.push_back(big);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
vector<int> G[MAXN];
struct node {
int pre, nxt;
};
node l[MAXN];
queue<int> q;
void init(int n) {
for (int i = 1; i <= n; ++i) {
l[i - 1].nxt = i;
l[i].pre = i - 1;
}
l[n].nxt = 0;
}
void del(int i) {
l[l[i].pre].nxt = l[i].nxt;
l[l[i].nxt].pre = l[i].pre;
}
int cnt, top = 0;
int ans[MAXN];
bool vis1[MAXN], vis2[MAXN];
void bfs() {
while (l[0].nxt) {
cnt = 1;
int now = l[0].nxt;
q.push(now);
del(now);
vis2[now] = 1;
while (!q.empty()) {
now = q.front();
q.pop();
for (auto i : G[now]) vis1[i] = 1;
for (int i = l[0].nxt; i; i = l[i].nxt)
if (!vis1[i] && !vis2[i]) {
++cnt;
q.push(i);
del(i);
vis2[i] = 1;
}
for (auto i : G[now]) vis1[i] = 0;
}
ans[++top] = cnt;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
init(n);
int a, b;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
bfs();
printf("%d\n", top);
sort(ans + 1, ans + top + 1);
for (int i = 1; i <= top; ++i) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int n, m;
set<int> unvis;
vector<set<int>> g;
int sz;
void dfs(int u) {
unvis.erase(u);
sz++;
bool ok = true;
while (ok) {
ok = false;
for (int v : unvis) {
if (g[u].count(v)) continue;
dfs(v);
ok = true;
break;
}
}
}
void solve() {
cin >> n >> m;
g.resize(n + 1);
for (int i = 0, x, y; i < m; i++) {
cin >> x >> y;
g[x].insert(y);
g[y].insert(x);
}
for (int i = 1; i <= n; i++) unvis.insert(i);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (unvis.count(i)) {
sz = 0;
dfs(i);
ans.push_back(sz);
}
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (int i : ans) cout << i << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tc = 1;
while (tc--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long double pi = 3.14159265358979323;
const double EPS = 1e-12;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
set<long long> s;
vector<long long> v[N];
int val;
void dfs(long long node) {
val++;
s.erase(node);
set<long long> st;
for (auto it : s) {
st.insert(it);
}
for (auto it : v[node]) {
if (st.find(it) != st.end()) st.erase(it);
}
for (auto it : st) {
s.erase(it);
}
for (auto it : st) {
dfs(it);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
s.insert(i);
}
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
long long ans = 0;
vector<long long> ans1;
for (int i = 1; i <= n; i++) {
if (s.find(i) != s.end()) {
val = 0;
dfs(i);
ans1.push_back(val);
}
}
cout << ans1.size() << "\n";
sort(ans1.begin(), ans1.end());
for (auto it : ans1) {
cout << it << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<long long>;
using vpi = vector<pair<ll, ll>>;
using pi = pair<ll, ll>;
const int mod = 1000000007;
set<int> adj[200000];
set<int> unvis;
int sz[200000];
int cur = 0;
void dfs(int x) {
sz[cur]++;
auto it = unvis.begin();
while (it != unvis.end()) {
if (adj[x].count(*it)) {
it++;
} else {
int last = *it;
unvis.erase(it);
dfs(last);
it = unvis.upper_bound(last);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].insert(b);
adj[b].insert(a);
}
for (int i = 0; i < n; i++) {
unvis.insert(i);
}
for (int i = 0; i < n; i++) {
auto it = unvis.find(i);
if (it != unvis.end()) {
unvis.erase(it);
dfs(i);
cur++;
}
}
cout << cur << endl;
sort(sz, sz + cur);
for (int i = 0; i < cur; i++) {
cout << sz[i] << ' ';
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5;
set<int> p;
set<int> g[MAXN + 10];
int P[MAXN + 10];
bool V[MAXN + 10];
int bfs(int cur) {
queue<int> q;
q.push(cur);
V[cur] = true;
int s = 0;
while (!q.empty()) {
int cur = q.front();
q.pop();
p.erase(cur);
set<int>::iterator it = p.begin();
s++;
while (it != p.end()) {
if (g[cur].count(*it)) {
it++;
} else {
q.push(*it);
V[*it] = true;
it = p.erase(it);
}
}
}
return s;
}
int S[MAXN + 10];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) p.insert(i);
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
g[u].insert(v);
g[v].insert(u);
}
int tot = 0;
for (int i = 1; i <= n; i++) {
if (!V[i]) {
S[tot++] = bfs(i);
}
}
printf("%d\n", tot);
sort(S, S + tot);
for (int i = 0; i < tot; i++) printf("%d ", S[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 998244353;
int lowbit(int x) { return x & (-x); }
int fast_power(int a, int b) {
int x;
for (x = 1; b; b >>= 1) {
if (b & 1) x = 1ll * x * a % mod;
a = 1ll * a * a % mod;
}
return x % mod;
}
pair<int, int> a[MAXN];
int ans[MAXN];
int fa[MAXN], head[MAXN], pre[MAXN], nxt[MAXN];
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
void merge(int x, int y) {
int fa_x = find(x), fa_y = find(y);
if (fa_x == fa_y) return;
fa[fa_x] = fa_y;
}
void del(int i) {
pre[nxt[i]] = pre[i];
nxt[pre[i]] = nxt[i];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) {
fa[i] = i;
nxt[i] = i + 1;
pre[i] = i - 1;
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[2 * i - 1] = make_pair(x, y);
a[2 * i] = make_pair(y, x);
}
sort(a + 1, a + 2 * m + 1);
for (int i = 1, k = 1; i <= n; i++) {
for (int j = nxt[0]; j <= n; j = nxt[j]) {
while (a[k].first < i || a[k].first == i && a[k].second < j) k++;
if (a[k].first == i && a[k].second == j) {
k++;
continue;
}
merge(j, i);
if (find(j) == find(nxt[j])) del(j);
}
}
for (int i = 1; i <= n; i++) ans[find(i)]++;
sort(ans + 1, ans + n + 1);
int res = 0;
for (int i = 1; i <= n; i++)
if (ans[i]) res++;
printf("%d\n", res);
for (int i = 1; i <= n; i++)
if (ans[i]) printf("%d ", ans[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
struct hash<pair<T, U>> {
size_t operator()(const pair<T, U>& key) const {
return (hash<T>()(key.first) ^ (hash<U>()(key.second) << 1)) << 1;
}
};
struct cc_complement {
int n;
set<pair<int, int>>& edges;
set<int> notvis;
vector<vector<int>> cc;
void bfs(int s) {
queue<int> q;
q.push(s);
notvis.erase(s);
while (q.size()) {
int u = q.front();
q.pop();
cc.back().push_back(u);
for (auto it = notvis.begin(); it != notvis.end();) {
if (!edges.count({u, *it}) && !edges.count({*it, u})) {
q.push(*it);
it = notvis.erase(it);
} else
++it;
}
}
}
cc_complement(int n_, set<pair<int, int>>& e) : n(n_), edges(e) {
for (int v = 1; v <= n; ++v) {
notvis.insert(v);
}
for (int v = 1; v <= n; ++v) {
if (notvis.count(v)) {
cc.emplace_back();
bfs(v);
}
}
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
set<pair<int, int>> edges;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
edges.insert({u, v});
}
vector<int> ans;
cc_complement cc(n, edges);
for (auto x : cc.cc) {
ans.push_back(x.size());
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int x : ans) {
cout << x << ' ';
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n, m;
cin >> n >> m;
set<pair<int, int> > edges;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
edges.insert(make_pair(u, v));
edges.insert(make_pair(v, u));
}
vector<int> pending;
for (int i = 1; i <= n; i++) {
pending.push_back(i);
}
vector<int> sizes;
while (pending.size()) {
int next = pending.back();
pending.pop_back();
int size = 1;
queue<int> component;
component.push(next);
while (component.size()) {
int u = component.front();
component.pop();
for (int i = 0; i < pending.size(); i++) {
if (edges.count(make_pair(u, pending[i])) == 0) {
size++;
component.push(pending[i]);
pending[i] = pending.back();
pending.pop_back();
i--;
}
}
}
sizes.push_back(size);
}
cout << sizes.size() << "\n";
sort(sizes.begin(), sizes.end());
for (auto v : sizes) {
cout << v << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int mo = 19260817;
int head[100005 << 1], k;
struct Edge {
int v;
int next;
} edge[100005 << 2];
struct union_find_set {
int root;
int num;
} ufs[100005 << 1];
void init(int n) {
for (int i = 1; i <= n; i++) ufs[i].root = i, ufs[i].num = 1;
}
int find(int x) {
return x == ufs[x].root ? x : ufs[x].root = find(ufs[x].root);
}
void uni(int x, int y) {
int xroot = find(x);
int yroot = find(y);
if (xroot != yroot) {
if (ufs[xroot].num >= ufs[yroot].num) {
ufs[yroot].root = xroot;
ufs[xroot].num += ufs[yroot].num;
} else {
ufs[xroot].root = yroot;
ufs[yroot].num += ufs[xroot].num;
}
}
}
void add(int u, int v) {
edge[k].v = v;
edge[k].next = head[u];
head[u] = k++;
}
void bfs(int n) {
queue<int> q;
vector<int> vec;
set<int> s1, s2;
for (int i = 2; i <= n; i++) s1.insert(i);
q.push(1);
while (!q.empty() || !s1.empty()) {
int u = q.front();
q.pop();
s2.clear();
vec.clear();
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
s2.insert(v);
}
for (auto it = s1.begin(); it != s1.end(); it++) {
if (s2.find(*it) == s2.end()) {
q.push(*it);
uni(u, *it);
vec.push_back(*it);
}
}
for (auto it = vec.begin(); it != vec.end(); it++) s1.erase(*it);
if (q.empty()) {
int tmp = -1;
for (auto it = s1.begin(); it != s1.end(); it++) {
q.push(*it);
tmp = *it;
break;
}
if (tmp != -1) s1.erase(tmp);
}
}
}
int ans[100005 << 1];
int main() {
int n, m, u, v, cnt;
while (~scanf("%d%d", &n, &m)) {
k = cnt = 0;
memset(head, -1, sizeof(head));
init(n);
while (m--) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
bfs(n);
for (int i = 1; i <= n; i++)
if (i == find(i)) ans[cnt++] = ufs[i].num;
sort(ans, ans + cnt);
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++)
printf("%d%c", ans[i], i == cnt - 1 ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int xx = 0, ff = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
xx = (xx << 3) + (xx << 1) + ch - '0';
ch = getchar();
}
return xx * ff;
}
const int maxn = 200010;
int N, M, t1, t2, temp[maxn], ans;
set<int> s;
map<int, bool> e[maxn];
void dfs(int x) {
int prev = 0;
while (1) {
int t = *s.lower_bound(prev);
if (t == (1 << 30)) break;
prev = t + 1;
if (!e[x][t]) {
temp[ans]++;
s.erase(t);
dfs(t);
}
}
}
int main() {
N = read(), M = read();
for (int i = 1; i <= N; i++) s.insert(i);
s.insert(1 << 30);
for (int i = 1; i <= M; i++) {
t1 = read(), t2 = read();
e[t1][t2] = e[t2][t1] = 1;
}
int prev = 0;
while (1) {
int t = *s.lower_bound(prev);
if (t == (1 << 30)) break;
prev = t + 1;
s.erase(t);
temp[++ans] = 1;
dfs(t);
}
sort(temp + 1, temp + 1 + ans);
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) printf("%d ", temp[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
set<pair<int, int> > s;
set<int> sc;
vector<int> ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> a >> b;
s.insert(make_pair(min(a, b), max(a, b)));
}
for (int i = 1; i <= n; ++i) {
sc.insert(i);
}
for (int i = 1; i <= n; ++i) {
if (sc.find(i) != sc.end()) {
int cur = 0;
queue<int> q;
q.push(i);
sc.erase(i);
while (!q.empty()) {
cur++;
int v = q.front();
q.pop();
set<int>::iterator it;
set<int> c = sc;
for (it = c.begin(); it != c.end(); it++) {
int to = *it;
if (s.find(make_pair(min(v, to), max(v, to))) == s.end()) {
q.push(to);
sc.erase(to);
}
}
}
ans.push_back(cur);
}
}
sort(ans.begin(), ans.end());
cout << (int)ans.size() << endl;
for (int i = 0; i < (int)ans.size(); ++i) {
cout << ans[i] << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans1, nj;
vector<long long> ans, v;
map<long long, long long> mp[200010];
set<long long> s;
queue<long long> q;
set<long long>::iterator it;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 1; i <= m; i++) {
long long xx, yy;
scanf("%lld", &xx);
scanf("%lld", &yy);
mp[xx][yy] = 1;
mp[yy][xx] = 1;
}
while (s.size()) {
q.push(*s.begin());
s.erase(*s.begin());
ans1 = 0;
while (q.size()) {
v.clear();
nj = q.front();
q.pop();
for (it = s.begin(); it != s.end(); it++) {
if (mp[nj][*it] == 0) {
v.push_back(*it);
q.push(*it);
ans1++;
}
}
for (int i = 0; i < v.size(); i++) s.erase(v[i]);
}
ans.push_back(ans1 + 1);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
int n, m, head[maxn], tot, cnt;
struct pp {
int nxt, to;
} g[maxn << 1];
void add(int u, int v) { g[++tot].nxt = head[u], g[tot].to = v, head[u] = tot; }
int c[maxn], r[maxn], l[maxn], vis[maxn], ans[maxn];
queue<int> q;
int bfs(int x) {
int sum = 1;
while (!q.empty()) q.pop();
vis[x] = 1;
q.push(x);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i != -1; i = g[i].nxt) c[g[i].to] = 1;
int t = 0;
while (r[t] != n + 1) {
t = r[t];
if (c[t]) continue;
if (!vis[t]) {
vis[t] = 1;
q.push(t);
sum++;
r[l[t]] = r[t], l[r[t]] = l[t];
}
}
for (int i = head[u]; i != -1; i = g[i].nxt) c[g[i].to] = 0;
}
return sum;
}
int main() {
memset(vis, 0, sizeof(vis));
cnt = 0;
memset(c, 0, sizeof(c));
memset(head, -1, sizeof(head));
tot = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 0; i <= n; i++) r[i] = i + 1;
for (int i = 1; i <= n + 1; i++) l[i] = i - 1;
for (int i = 1; i <= n; i++)
if (!vis[i]) ans[++cnt] = bfs(i);
printf("%d\n", cnt);
sort(ans + 1, ans + cnt + 1);
for (int i = 1; i <= cnt; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int p[200001];
set<int> v[200001];
set<int> unused;
vector<int> components;
int c = 0;
void dfs(int x) {
unused.erase(x);
components[c]++;
int curr = 0;
while (1) {
set<int>::iterator i = unused.upper_bound(curr);
if (i == unused.end()) break;
curr = *i;
if (v[x].count(curr)) continue;
dfs(curr);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].insert(y);
v[y].insert(x);
}
for (int i = 1; i <= n; i++) unused.insert(i);
for (int i = 1; i <= n; i++)
if (unused.count(i)) {
components.push_back(0);
dfs(i);
c++;
}
sort(components.begin(), components.end());
printf("%d\n", c);
for (int i = 0; i < c; i++) printf("%d ", components[i]);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, -1, 0, 0};
long long dy[] = {0, 0, 1, -1};
const int sz = 200005, mod = 1e9 + 9;
long long t, n, m, ans = mod;
long long Power(long long a, long long b) {
if (a == 0) return 0;
if (b == 0) return 1;
long long ans = Power((a * a) % mod, b / 2);
if (b & 1) return (a * ans) % mod;
return ans % mod;
}
long long Inv(long long a) { return Power(a, mod - 2); }
vector<set<long long> > Gr(sz);
vector<int> vis(sz);
set<long long> Set;
void DFS(int s) {
queue<int> q;
q.push(s);
Set.erase(s);
while (q.size()) {
int y = q.front();
q.pop();
if (vis[y]) continue;
vis[y] = 1;
vector<int> del;
for (auto i : Set) {
if (Gr[y].find(i) == Gr[y].end()) {
del.push_back(i);
q.push(i);
}
}
for (auto i : del) Set.erase(i);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
Gr[a].insert(b);
Gr[b].insert(a);
}
for (int i = 1; i <= n; i++) Set.insert(i);
int cnt = 0;
vector<int> v;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
long long xx = Set.size();
DFS(i);
long long yy = Set.size();
v.push_back(xx - yy);
cnt++;
}
}
sort(v.begin(), v.end());
cout << cnt << "\n";
for (auto i : v) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
int cnt;
using namespace std;
set<int> adj[200005];
set<int> s2;
void bfs(int a) {
queue<int> q;
q.push(a);
s2.erase(s2.find(a));
while (!q.empty()) {
a = q.front();
q.pop();
vector<int> aux;
for (auto it = s2.begin(); it != s2.end(); it++) {
int u = (*it);
if (adj[a].find(u) == adj[a].end()) {
cnt++;
q.push(u);
aux.push_back(u);
}
}
for (int i = 0; i < aux.size(); i++) s2.erase(s2.find(aux[i]));
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
adj[a].insert(b);
adj[b].insert(a);
}
for (int i = 1; i <= n; i++) s2.insert(i);
vector<int> v;
for (int i = 1; i <= n; i++) {
if (s2.find(i) != s2.end()) {
cnt = 1;
bfs(i);
v.push_back(cnt);
}
}
sort(v.begin(), v.end());
cout << v.size() << endl;
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<long long>;
using vpi = vector<pair<ll, ll>>;
using pi = pair<ll, ll>;
const int mod = 1000000007;
set<ll> adj[200005];
ll group[200005];
vi cvis;
ll cmin;
bool vis[200005];
ll n, m;
ll ret[200005];
void dfs(ll x) {
cvis.push_back(x);
vis[x] = true;
for (ll i = 0; i < n; i++) {
if (x != i && adj[x].find(i) == adj[x].end()) {
if (group[i] == 1) {
cmin = 1;
continue;
} else {
if (!vis[i]) {
dfs(i);
}
}
}
}
}
signed main() {
ll t = 1;
while (t--) {
cin >> n >> m;
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
a--;
b--;
adj[a].insert(b);
adj[b].insert(a);
}
ll cur = 1;
for (ll i = 0; i < n; i++) {
if (n - adj[i].size() > n / 2) {
group[i] = 1;
ret[1]++;
cur = 2;
}
}
for (ll i = 0; i < n; i++) {
if (!group[i]) {
cmin = cur;
dfs(i);
for (ll j : cvis) {
group[j] = cmin;
ret[cmin]++;
}
cvis.clear();
if (cmin != 1 || cur == 1) {
cur++;
}
}
}
cout << cur - 1 << endl;
sort(ret, ret + cur);
for (ll i = 1; i < cur; i++) {
cout << ret[i] << ' ';
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<int> adj[200005];
set<int> s;
set<int>::iterator p;
vector<int> ans;
int bfs(int x) {
s.erase(x);
int cnt = 0;
queue<int> q;
q.push(x);
int u = 0, v = 0;
while (!q.empty()) {
u = q.front();
q.pop();
cnt++;
for (p = s.begin(); p != s.end();) {
v = *p;
if (adj[u].count(v)) {
p++;
continue;
} else {
q.push(v);
s.erase(p++);
}
}
}
return cnt;
}
int main() {
scanf("%d%d", &n, &m);
for (int u, v, i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
adj[u].insert(v);
adj[v].insert(u);
}
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 1; i <= n; i++) {
if (s.count(i)) ans.push_back(bfs(i));
}
printf("%d\n", ans.size());
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
class snp {
public:
snp(int n) {
mas = new int[n + 1];
for (int i = 1; i <= n; i++) mas[i] = i;
}
~snp() { delete[] mas; }
int get(int v) {
if (v == mas[v])
return v;
else
return mas[v] = get(mas[v]);
}
void set(int v, int gr) { mas[v] = gr; }
private:
int *mas;
};
std::map<int, std::set<int>> not_way;
snp *s;
std::set<int> not_used;
std::set<int>::iterator it;
int n, m;
int dfs(int v, int gr) {
int count = 1;
not_used.erase(v);
s->set(v, gr);
int i = 0;
while (!not_used.empty()) {
it = not_used.upper_bound(i);
if (it == not_used.end()) break;
i = *it;
if (not_way[v].find(i) == not_way[v].end()) count += dfs(i, gr);
}
return count;
}
int main() {
scanf("%d%d", &n, &m);
s = new snp(n + 1);
for (int i = 1; i <= n; i++) not_used.insert(i);
int a, b;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
not_way[a].insert(b);
not_way[b].insert(a);
}
int group = 1;
int *groups = new int[n + 1];
int i = 0;
while (!not_used.empty()) {
it = not_used.upper_bound(i);
if (it == not_used.end()) break;
i = *it;
groups[group] = dfs(i, group);
group++;
}
printf("%d\n", group - 1);
std::sort(groups + 1, groups + group);
for (int i = 1; i < group; i++) printf("%d ", groups[i]);
delete s;
delete groups;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
int n, m;
set<int> valid;
vector<int> g[N];
vector<int> par;
int findpar(int u) {
if (par[u] == u) return u;
return par[u] = findpar(par[u]);
}
void add(int x, int y) { par[findpar(x)] = findpar(y); }
int main() {
std ::ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
par.resize(n + 1);
for (int i = 1; i <= n; ++i) {
valid.insert(i);
par[i] = i;
}
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
g[x].emplace_back(y);
g[y].emplace_back(x);
}
for (int i = 1; i <= n; ++i) {
sort(g[i].begin(), g[i].end());
}
priority_queue<int, vector<int>, greater<int> > out;
for (int i = 1; i <= n; ++i) {
int ans = 0;
if (valid.count(i)) {
queue<int> Q;
queue<int> cut;
Q.emplace(i);
valid.erase(i);
while (!Q.empty()) {
int from = Q.front();
++ans;
Q.pop();
for (auto s : valid) {
if (!binary_search(g[from].begin(), g[from].end(), s)) {
Q.emplace(s);
cut.emplace(s);
add(s, from);
}
}
while (!cut.empty()) {
valid.erase(cut.front());
cut.pop();
}
}
out.emplace(ans);
}
}
cout << out.size() << '\n';
while (!out.empty()) {
cout << out.top() << ' ';
out.pop();
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
map<pair<long long, long long>, bool> mp;
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
mp[make_pair(u, v)]++;
mp[make_pair(v, u)]++;
}
vector<long long> vresp;
deque<long long> dq;
while (n) {
dq.push_back(n--);
}
while (!dq.empty()) {
long long c = 1, p = dq.front();
dq.pop_front();
queue<long long> q;
q.push(p);
while (!q.empty()) {
long long x = dq.size();
p = q.front();
q.pop();
while (x--) {
long long xx = dq.front();
dq.pop_front();
if (mp[make_pair(p, xx)]) {
dq.push_back(xx);
} else {
q.push(xx);
c++;
}
}
}
vresp.push_back(c);
}
cout << vresp.size() << endl;
sort(vresp.begin(), vresp.end());
for (auto T : vresp) cout << T << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200006;
set<int> mp[MAXN], s;
vector<int> ans;
int dfs(int id) {
int res = 1;
for (set<int>::iterator it = s.begin(); it != s.end();) {
if (mp[id].find(*it) == mp[id].end()) {
int x = *it;
s.erase(x);
res += dfs(x);
it = s.lower_bound(x);
} else
it++;
}
return res;
}
int main() {
int n, m, x, y, t;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
mp[x].insert(y);
mp[y].insert(x);
}
for (int i = 1; i <= n; i++) {
s.insert(i);
}
while (!s.empty()) {
t = *s.begin();
s.erase(t);
ans.push_back(dfs(t));
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (vector<int>::iterator it = ans.begin(); it != ans.end(); it++) {
printf("%d ", *it);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
set<int> rem;
struct dsu {
vector<int> p, sz;
int comp;
void init(int NN) {
sz.clear();
p.clear();
p.resize(NN);
sz.resize(NN, 1);
iota(p.begin(), p.end(), 0);
comp = NN;
}
int get(int x) { return (x == p[x] ? x : (p[x] = get(p[x]))); }
void unite(int x, int y) {
x = get(x);
y = get(y);
if (x != y) {
p[x] = y;
sz[y] += sz[x];
sz[x] = 0;
comp--;
}
}
} g;
int n;
set<int> mp[N];
void dfs(int cur) {
rem.erase(cur);
vector<int> v;
for (auto i : rem) {
if (mp[cur].find(i) == mp[cur].end()) {
v.push_back(i);
g.unite(cur, i);
}
}
for (auto ele : v) {
rem.erase(ele);
}
for (auto ele : v) {
dfs(ele);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{
int i, j, k, m, ans = 0, cnt = 0, sum = 0;
cin >> n >> m;
for (i = 1; i <= n; i++) {
rem.insert(i);
}
int l, r;
for (i = 0; i < m; i++) {
cin >> l >> r;
mp[l].insert(r);
mp[r].insert(l);
}
g.init(n + 1);
for (i = 1; i <= n; i++) {
if (rem.find(i) != rem.end()) dfs(i);
}
vector<int> v;
map<int, bool> mpp;
for (i = 1; i <= n; i++) {
if (mpp[g.get(i)] == 0) {
mpp[g.get(i)] = 1;
v.push_back(g.sz[g.get(i)]);
}
}
sort(v.begin(), v.end());
cout << v.size() << "\n";
for (auto ele : v) {
cout << ele << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream second(s);
string x;
while (getline(second, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
err(++it, args...);
}
int ini() {
int x;
scanf("%d", &x);
return x;
}
long long inl() {
long long x;
scanf("%lld", &x);
return x;
}
double ind() {
double x;
scanf("%lf", &x);
return x;
}
int set_1(int n, int pos) { return n = (n | (1 << pos)); }
int reset_0(int n, int pos) { return n = n & ~(1 << pos); }
bool check_bit(int n, int pos) { return n = n & (1 << pos); }
int dx[8] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[8] = {0, 1, 0, -1, -1, 1, -1, 1};
const int N = (int)2e5 + 5;
const int M = (int)1e9 + 7;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
std::set<int> contain[N];
bool vis[N];
set<int> unused;
int c;
void dfs(int u) {
unused.erase(u);
vis[u] = true;
set<int>::iterator it = unused.begin();
c++;
std::vector<int> v;
while (it != unused.end()) {
if (contain[u].count(*it) == 0) {
v.push_back(*it);
}
++it;
}
for (auto x : v) {
unused.erase(x);
}
for (auto x : v) {
dfs(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1, te = 0;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
contain[u].insert(v);
contain[v].insert(u);
}
for (int i = 1; i <= n; i++) {
unused.insert(i);
}
vector<int> v;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
c = 0;
dfs(i);
v.push_back(c);
}
}
cout << v.size() << '\n';
;
sort(v.begin(), v.end());
for (auto x : v) {
cout << x << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<long long>;
using vpi = vector<pair<ll, ll>>;
using pi = pair<ll, ll>;
const int mod = 1000000007;
set<ll> adj[200005];
ll group[200005];
vi cvis;
ll cmin;
bool vis[200005];
ll n, m;
ll ret[200005];
void dfs(ll x) {
cvis.push_back(x);
vis[x] = true;
for (ll i = 0; i < n; i++) {
if (x != i && adj[x].find(i) == adj[x].end()) {
if (group[i] == 1) {
cmin = 1;
continue;
} else {
if (!vis[i]) {
dfs(i);
}
}
}
}
}
signed main() {
ll t = 1;
while (t--) {
cin >> n >> m;
for (ll i = 0; i < m; i++) {
ll a, b;
cin >> a >> b;
a--;
b--;
adj[a].insert(b);
adj[b].insert(a);
}
ll cur = 1;
for (ll i = 0; i < n; i++) {
if (adj[i].size() < (n + 1) / 2) {
group[i] = 1;
ret[1]++;
cur = 2;
}
}
for (ll i = 0; i < n; i++) {
if (!group[i]) {
cmin = cur;
dfs(i);
for (ll j : cvis) {
group[j] = cmin;
ret[cmin]++;
}
cvis.clear();
if (cmin != 1 || cur == 1) {
cur++;
}
}
}
cout << cur - 1 << endl;
sort(ret, ret + cur);
for (ll i = 1; i < cur; i++) {
cout << ret[i] << ' ';
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct $ {
$() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(9);
}
} $;
const int N = 200001;
bool vis[N];
set<int> adj[N];
set<int> gadj;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
multiset<int> sizes;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
for (int i = 1; i <= n; i++) gadj.insert(i);
int size = 0;
vis[i] = true;
deque<int> Q = {i};
while (!Q.empty()) {
size++;
int u = Q.front();
Q.pop_front();
vector<int> ne;
for (int v : gadj) {
if (!adj[u].count(v)) {
if (!vis[v]) {
ne.push_back(v);
}
}
}
for (int v : ne) {
vis[v] = true;
gadj.erase(v);
Q.push_back(v);
}
}
sizes.insert(size);
}
}
cout << sizes.size() << endl;
int sum = 0;
for (int u : sizes) {
cout << u << " ";
sum += u;
}
assert(sum == n);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int inf = 1e9 + 5;
int n, m;
set<int> s;
set<int> g[maxn];
vector<int> res;
int dfs(int v) {
s.erase(v);
int x = 0, kol = 1;
while (1) {
auto koji = s.upper_bound(x);
if (koji == s.end()) break;
x = *koji;
if (!g[v].count(x)) kol += dfs(x);
}
return kol;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
cin >> n >> m;
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].insert(v);
g[v].insert(u);
}
for (int i = 1; i <= n; i++) {
if (s.count(i)) res.push_back(dfs(i));
}
sort(res.begin(), res.end());
cout << res.size() << endl;
for (auto c : res) cout << c << " ";
cout << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.