solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int N, R, C;
string arr[1000100];
int best[1000100];
int dp[1000100][22];
int main() {
scanf("%d%d%d", &N, &R, &C);
for (int i = 1; i <= N; i++) {
cin >> arr[i];
}
int r = 1;
int cur = (int)arr[1].size() + 1;
for (int i = 1; i <= N; i++) {
while (r <= N && cur <= C + 1) {
r++;
if (r != N + 1) cur += arr[r].size() + 1;
}
best[i] = r;
cur -= (arr[i].size() + 1);
}
for (int i = 1; i <= N; i++) {
dp[i][0] = best[i];
}
for (int i = 1; i <= log2(N); i++) {
for (int j = 1; j <= N; j++) {
dp[j][i] = dp[dp[j][i - 1]][i - 1];
}
}
int beg = 1;
int ans = 0;
for (int i = 1; i <= N; i++) {
int node = i;
for (int j = 0; j <= log2(R); j++) {
if ((1 << j) & R) {
node = dp[node][j];
}
}
if (ans < node - i) {
ans = node - i;
beg = i;
}
}
cur = beg;
int nx = best[beg];
for (int i = 1; i <= R; i++) {
if (nx == cur) break;
for (int j = cur; j < nx; j++) {
cout << arr[j];
if (j != nx - 1) printf(" ");
}
printf("\n");
cur = best[cur];
nx = best[nx];
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, r, c, i, j, k, ans;
int l[1000005], len[1000005], sum[1000005];
int f[1000005], g[1000005], gg[1000005];
char s[10000005];
void dfs(int x, int y) {
if (!x) return;
if (!f[y]) return;
dfs(x - 1, f[y] - 1);
for (int i = f[y]; i <= y; ++i) {
printf("%s", s + l[i]);
if (i != y)
printf(" ");
else
printf("\n");
}
}
int main() {
scanf("%d%d%d", &n, &r, &c);
for (i = 1; i <= n; ++i) {
k += 2;
scanf("%s", s + k);
l[i] = k;
len[i] = strlen(s + k);
k += len[i];
}
for (i = 1; i <= n; ++i) sum[i] = sum[i - 1] + len[i];
for (i = 1; i <= n; ++i)
if (len[i] <= c) {
if (f[i - 1]) {
f[i] = f[i - 1];
for (; sum[i] - sum[f[i] - 1] + i - f[i] > c; ++f[i])
;
} else
f[i] = i;
}
for (i = 1; i <= n; ++i) g[i] = gg[i] = f[i];
for (i = r - 1; i; i >>= 1) {
if (i & 1) {
for (j = n; j >= 1; --j)
if (g[j] && gg[g[j] - 1]) g[j] = gg[g[j] - 1];
}
for (j = n; j >= 1; --j)
if (gg[j] && gg[gg[j] - 1]) gg[j] = gg[gg[j] - 1];
}
for (i = 1; i <= n; ++i)
if (g[i] && i - g[i] + 1 > ans) ans = i - g[i] + 1;
for (i = 1; i <= n; ++i)
if (g[i] && i - g[i] + 1 == ans) break;
dfs(r, i);
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXW = 5000000, MAXN = 1000010;
char buf[MAXW + 10];
vector<string> W;
int c[MAXN], sum[MAXN], last[20][MAXN];
int res[MAXN];
int main(void) {
int n, R, C;
scanf("%d%d%d", &n, &R, &C);
W = vector<string>(n);
for (int i = 0; i < (n); ++i) {
scanf("%s", buf);
W[i] = buf;
c[i] = ((int)((W[i]).size()));
}
sum[0] = c[0];
for (int i = (1); i < (n); ++i) {
sum[i] = sum[i - 1] + c[i];
}
for (int i = 0; i < (n); ++i) {
res[i] = -2;
}
for (int i = 0; i < (n); ++i) {
int l = i, r = n - 1, best = -1;
while (l <= r) {
int mid = (l + r) / 2;
int L = sum[mid] - (i == 0 ? 0 : sum[i - 1]) + (mid - i);
if (L <= C) {
best = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
last[0][i] = best;
}
for (int b = 1; (1 << b) <= R; ++b) {
int w = b - 1;
for (int i = 0; i < (n); ++i) {
if (last[w][i] == -1 || last[w][i] == n - 1 ||
last[w][last[w][i] + 1] == -1) {
last[b][i] = -1;
} else {
last[b][i] = last[w][last[w][i] + 1];
}
}
}
for (int i = 0; i < (n); ++i) {
if (last[0][i] == -1) {
res[i] = -1;
} else {
res[i] = i;
}
int b, cur = i, rem = R;
for (b = 0; (1 << b) <= R; ++b)
;
for (--b; b >= 0; --b) {
if ((1 << b) > rem) {
continue;
}
if (cur < n && last[b][cur] != -1) {
res[i] = last[b][cur];
rem -= (1 << b);
cur = last[b][cur] + 1;
}
}
}
int best = -1;
for (int i = 0; i < (n); ++i) {
if (res[i] == -1) {
continue;
}
if (best == -1 || res[i] - i > res[best] - best) {
best = i;
}
}
if (best == -1) {
return 0;
}
int cur = 0;
for (int i = 0, j = 0; j < R && best + i < n; ++i) {
int k = i + best;
if (c[k] > C) {
break;
}
if (cur + c[k] + (cur == 0 ? 0 : 1) <= C) {
printf("%s%s", (cur == 0 ? "" : " "), W[k].c_str());
cur += c[k] + (cur == 0 ? 0 : 1);
} else {
++j;
if (j == R) {
break;
}
printf("\n%s", W[k].c_str());
cur = c[k];
}
}
puts("");
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
int n, m, r, c, i, j, k, cur, nx, res, w, a[1000100], b[20][1000100],
st[1000100];
char s[5000100];
int main() {
scanf("%d%d%d", &n, &r, &c);
for (i = 0; i < n; i++) {
st[i] = m;
scanf("%s", s + m);
a[i] = strlen(s + m);
m += a[i];
}
for (i = 0; i < n; i++) {
if (i == 0 || b[0][i - 1] <= i) {
b[0][i] = i;
cur = 0;
} else {
b[0][i] = b[0][i - 1];
cur -= a[i - 1] + 1;
}
while (b[0][i] < n) {
nx = cur;
if (nx > 0) nx++;
nx += a[b[0][i]];
if (nx > c) break;
cur = nx;
b[0][i]++;
}
}
b[0][n] = n;
for (j = 1; j < 20; j++)
for (i = 0; i <= n; i++) b[j][i] = b[j - 1][b[j - 1][i]];
for (i = 0; i <= n; i++) {
cur = r;
nx = i;
for (j = 19; j >= 0; j--)
if (cur >= (1 << j)) {
cur -= 1 << j;
nx = b[j][nx];
}
if (nx - i > res) {
res = nx - i;
w = i;
}
}
for (i = 0; i < r; i++) {
for (j = w; j < b[0][w]; j++) {
if (j != w) putchar(' ');
for (k = 0; k < a[j]; k++) putchar(s[st[j] + k]);
}
putchar('\n');
w = b[0][w];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int ddx[] = {0, 0, 1, 1, 1, -1, -1, -1}, ddy[] = {1, -1, 1, 0, -1, 1, 0, -1};
string s[1000000];
int n, r, c, to[1000001][20];
pair<int, int> p[1000000];
int res(int l) {
int now = l;
for (int(i) = (19); (i) >= (0); (i) -= (1)) {
if (r & (1 << i)) {
now = to[now][i];
}
}
return now - l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r >> c;
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) cin >> s[i];
p[0].first = 0, p[0].second = s[0].length() - 1;
for (int(i) = (1); (i) <= (n - 1); (i) += (1)) {
p[i].first = p[i - 1].second + 2;
p[i].second = p[i].first + s[i].length() - 1;
}
to[n][0] = n;
int rr = 0;
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
if (s[i].length() > c) {
to[i][0] = i;
rr = i + 1;
} else {
while (rr < n && p[rr].second - p[i].first + 1 <= c) rr++;
to[i][0] = rr;
}
}
for (int(j) = (1); (j) <= (19); (j) += (1))
for (int(i) = (0); (i) <= (n); (i) += (1))
to[i][j] = to[to[i][j - 1]][j - 1];
int ans = -1, what = -1;
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
int t = res(i);
if (t > ans) {
ans = t;
what = i;
}
}
for (int(i) = (0); (i) <= (r - 1); (i) += (1)) {
for (int(j) = (what); (j) <= (to[what][0] - 1); (j) += (1)) {
if (j != what) cout << ' ';
cout << s[j];
}
cout << '\n';
what = to[what][0];
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000005;
int n, r, c;
string str;
string s[MAX_N];
int sum[MAX_N];
int siz[MAX_N];
int to[MAX_N];
int f[MAX_N][21];
int calc(int l, int r) { return sum[r] - sum[l - 1] + (r - l); }
int main() {
cin >> n >> r >> c;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) siz[i] = s[i].size();
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + siz[i];
int pt = 1;
for (int i = 1; i <= n; i++) {
if (siz[i] > c) {
to[i] = -1;
continue;
}
while (pt < n && calc(i, pt + 1) <= c) pt++;
to[i] = pt;
}
for (int i = 1; i <= n; i++) f[i][0] = to[i] + 1;
for (int j = 1; j <= 20; j++) {
for (int i = 1; i <= n; i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
}
}
int lb = 1, ub = 0;
for (int i = 1; i <= n; i++) {
int pt = i;
int skip = r;
for (int j = 20; j >= 0; j--) {
if (f[pt][j] && skip >= (1 << j)) {
pt = f[pt][j];
skip -= (1 << j);
}
}
if (pt - i > ub - lb + 1) {
ub = pt - 1;
lb = i;
}
}
string str;
for (int i = lb; i <= ub; i++) {
if (!str.empty() && str.size() + 1 + s[i].size() > c) {
cout << str << endl;
str = "";
}
if (str.empty())
str += s[i];
else if (!str.empty() && str.size() + 1 + s[i].size() <= c)
str += ' ' + s[i];
}
if (!str.empty()) cout << str << endl;
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int a[1000007];
int b[1000007];
int f[1000007];
bool vist[1000007];
int m, n;
int R, C;
int ans;
string cc;
int main() {
char ch;
int i, j, k, p;
int len;
scanf("%d%d%d", &n, &R, &C);
scanf("%c", &ch);
m = 0;
j = 0;
a[0] = -1;
getline(cin, cc);
len = cc.length();
for (i = 0; i < len; ++i) {
ch = cc[i];
if (ch == ' ') {
a[++j] = i;
}
}
a[++j] = i;
j = 1;
for (i = 0; i < n; ++i) {
while (j <= n && a[j] - a[i] - 1 <= C) ++j;
b[i] = j - 1;
}
memset(vist, 0, sizeof(vist));
memset(f, 128, sizeof(128));
b[n] = n;
for (i = 0; i < n; ++i) {
if (vist[i]) continue;
k = i;
for (j = 0; j < R; ++j) {
if (b[k] == k) break;
k = b[k];
}
j = i;
while (true) {
f[j] = k;
if (vist[j] || j == b[j]) break;
vist[j] = true;
j = b[j];
k = b[k];
}
}
ans = -1;
for (i = 0; i < n; ++i) {
if (f[i] < 0) continue;
if (ans < 0 || f[i] - i > f[ans] - ans) ans = i;
}
if (ans < 0) {
for (i = 0; i < R; ++i) {
for (j = 0; j < C; ++j) printf(" ");
printf("\n");
}
} else {
j = ans;
for (i = 0; i < R; ++i) {
k = b[j];
for (p = a[j] + 1; p < a[k]; ++p) printf("%c", cc[p]);
j = b[j];
if (i < R - 1) printf("\n");
}
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int ln[1100100];
int nxt[1100100][22];
string strs[1100100];
char ch[5500500];
int main() {
int N, R, C;
scanf("%d%d%d", &N, &R, &C);
for (int i = 0; i < N; i++) {
scanf("%s", ch);
string tmp(ch);
ln[i] = strlen(ch) + 1;
strs[i] = tmp;
}
C++;
int s = 0, t = 0;
int nl = 0;
while (s < N) {
while (t < N && nl <= C) {
if (nl + ln[t] <= C) {
nl += ln[t];
t++;
} else
break;
}
nxt[s][0] = t;
nl -= ln[s];
s++;
}
for (int j = 1; j < 22; j++) {
for (int i = 0; i < N; i++) {
if (nxt[i][j - 1] == N)
nxt[i][j] = N;
else
nxt[i][j] = nxt[nxt[i][j - 1]][j - 1];
}
}
int max_words = -1;
int max_id = -1;
for (int i = 0; i < N; i++) {
int tmp = i;
for (int j = 0; j < 22; j++) {
if (((R >> j) & 1) == 1) tmp = nxt[tmp][j];
if (tmp == N) break;
}
if (max_words < tmp - i) {
max_words = tmp - i;
max_id = i;
}
}
if (max_id == -1) {
printf("\n");
return 0;
}
int id = max_id;
for (int i = 0; i < R; i++) {
for (int j = id; j < nxt[id][0]; j++) {
printf("%s%c", strs[j].c_str(), j == nxt[id][0] - 1 ? '\n' : ' ');
}
id = nxt[id][0];
if (id == N) break;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000 + 100;
int n, r, c;
string s[maxn];
int len[maxn];
int dp[maxn][22];
int main() {
ios::sync_with_stdio(false);
cin >> n >> r >> c;
c++;
for (int i = 0, _n = (int)(n); i < _n; i++) {
cin >> s[i];
len[i] = (int((s[i]).size())) + 1;
}
int tot = 0, end = n;
for (int j = 0, _n = (int)(22); j < _n; j++) dp[n][j] = n;
for (int i = (int)(n), _x = (int)(0); i-- > _x;) {
tot += len[i];
while (tot > c) tot -= len[--end];
dp[i][0] = end;
for (int j = (int)(1), _n = (int)(22); j < _n; j++)
dp[i][j] = dp[dp[i][j - 1]][j - 1];
}
int mx = -1, start = 0;
for (int i = 0, _n = (int)(n); i < _n; i++) {
int rr = r;
int end = i;
for (int j = 0, _n = (int)(22); j < _n; j++) {
if (rr & 1) end = dp[end][j];
rr /= 2;
}
if (end - i > mx) mx = end - i, start = i;
}
int now = c + 1, dt = 0;
for (int i = (int)(start), _n = (int)(start + mx); i < _n; i++) {
if (now + len[i] > c) {
now = 0;
if (dt) cout << endl;
} else
cout << " ";
now += len[i];
dt = 1;
cout << s[i];
}
cout << endl;
{
int _;
cin >> _;
return 0;
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
char s[5100000];
int sc[1000003][20];
int main() {
int n, r, c;
scanf("%d%d%d", &n, &r, &c);
vector<int> v;
vector<string> txt;
while (scanf("%s", s) == 1) {
v.push_back(strlen(s));
txt.push_back((string)s);
}
assert(v.size() == n);
vector<long long> sum(n + 1);
for (int i = 0; i < v.size(); ++i) sum[i + 1] = sum[i] + v[i];
int it = 0;
for (int i = 0; i < n; ++i) {
while (it <= n && sum[it] - sum[i] + it - i - 1 <= c) ++it;
sc[i][0] = it - 1;
}
for (int i = 0; i < 20; ++i) sc[n][i] = n;
for (int i = 1; i < 20; ++i)
for (int j = 0; j < n; ++j) sc[j][i] = sc[sc[j][i - 1]][i - 1];
int best = 0;
long long ma = 0;
for (int i = 0; i < n; ++i) {
int pos = i;
for (int pw = 0; pw < 20; ++pw)
if (r & (1 << pw)) pos = sc[pos][pw];
if (ma < pos - i) {
best = i;
ma = pos - i;
}
}
for (int i = 0; i < r; ++i) {
if (sc[best][0] == best) break;
string out = "";
for (int j = best; j < sc[best][0]; ++j) {
out += txt[j];
if (j + 1 < sc[best][0]) out += " ";
}
best = sc[best][0];
printf("%s\n", out.c_str());
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
const int N = 1e6 + 6;
const int LEN = 5e6 + 6;
char s[LEN];
int n, nr, nc, a[N], to[N][20], mx, str;
int main() {
scanf("%d%d%d", &n, &nr, &nc);
for (int i = 1; i <= n; ++i)
scanf("%s", s + a[i - 1]), a[i] = strlen(s + a[i - 1]) + a[i - 1];
for (int i = 1, j = 1; i <= n; ++i) {
if (j < i) j = i;
while (j <= n && a[j] - a[i - 1] + j - i <= nc) ++j;
to[i][0] = j;
}
to[n + 1][0] = n + 1;
for (int k = 1; k < 20; ++k) {
for (int i = 1; i <= n; ++i) to[i][k] = to[to[i][k - 1]][k - 1];
to[n + 1][k] = n + 1;
}
mx = 0, str = 0;
for (int l = 1; l <= n; ++l) {
int r = l;
for (int k = 19; ~k; --k)
if ((nr >> k) & 1) r = to[r][k];
if (r - l > mx) mx = r - l, str = l;
}
if (str) {
for (int i = 1; i <= nr; ++i) {
if (str == to[str][0]) break;
for (int j = str; j < to[str][0]; ++j) {
if (j ^ str) putchar(' ');
for (int k = a[j - 1]; k < a[j]; ++k) putchar(s[k]);
}
printf("\n");
str = to[str][0];
}
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
using pi = pair<int, int>;
const double PI = acos(-1.0);
const double eps = 1e-9;
const ll mod = 1e9 + 7;
const int inf = 1e7;
const int MAXN = 1e5 + 5;
void cp() {
int n, R, C;
cin >> n >> R >> C;
vector<string> arr(n);
for (auto &x : arr) cin >> x;
vector<vector<int>> lift(22, vector<int>(n + 1));
for (int i = 0; i <= 21; i++)
for (int j = 0; j <= n; j++) lift[i][j] = j;
int j = -1, cnt = 0;
for (int i = 0; i < n; i++) {
if (j < i) {
j = i, cnt = ((int)arr[i].size());
if (cnt > C) continue;
}
while (j + 1 < n && cnt + ((int)arr[j + 1].size()) + (j - i + 1) <= C)
j++, cnt += ((int)arr[j].size());
lift[0][i] = j + 1;
cnt -= ((int)arr[i].size());
}
for (int i = 1; i <= 21; i++)
for (int j = 0; j < n; j++) lift[i][j] = lift[i - 1][lift[i - 1][j]];
int idx = -1, best = -1;
for (int i = 0; i < n; i++) {
if (((int)arr[i].size()) > C) continue;
int k = i;
for (j = 21; j >= 0; j--) {
if ((R >> j) & 1) k = lift[j][k];
}
int have = k - i;
if (have > best) best = have, idx = i;
}
if (best == -1) return;
j = idx;
cnt = 0;
string ans;
while (j < n && best > 0) {
if (((int)ans.size()) + (!ans.empty()) + ((int)arr[j].size()) <= C) {
if (!ans.empty()) ans += ' ';
ans += arr[j];
} else
cout << ans << '\n', ans = arr[j];
j++;
best--;
}
if (!ans.empty() && best >= 0) cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
cp();
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int maxs = (int)6e6 + 10;
char tmp[maxs];
const int maxn = (int)1e6 + 10;
char* words[maxn];
int a[maxn];
int f[maxn];
int sum[maxn + 1];
int value[2][maxn];
void jump(int n, int r, int id) {
if (r > 1) {
jump(n, r / 2, id ^ 1);
for (int i = 0; i < n; ++i) {
value[id][i] = value[id ^ 1][i];
if (value[id][i] < n) value[id][i] = value[id ^ 1][value[id][i]];
}
} else {
for (int i = 0; i < n; ++i) value[id][i] = i;
}
if (r & 1) {
for (int i = 0; i < n; ++i) {
if (value[id][i] < n) value[id][i] = f[value[id][i]];
}
}
}
bool solve() {
int n, r, c;
if (scanf("%d%d%d ", &n, &r, &c) < 3) return 0;
gets(tmp);
int cnt = 0;
for (int pos = 0, len = strlen(tmp); pos < len;) {
while (pos < len && isspace(tmp[pos])) ++pos;
if (pos == len) break;
words[cnt++] = tmp + pos;
int& cur = a[cnt - 1];
cur = 1;
while (pos < len && !isspace(tmp[pos])) ++pos, ++cur;
}
assert(cnt == n);
sum[0] = 0;
for (int i = 0; i < n; ++i) sum[i + 1] = sum[i] + a[i];
for (int i = 0; i < n; ++i) {
int l = i, r = n + 1;
while (l + 1 < r) {
int m = (l + r) / 2;
if (sum[m] - sum[i] <= c + 1)
l = m;
else
r = m;
}
f[i] = l;
}
jump(n, r, 0);
int where = 0;
for (int i = 1; i < n; ++i) {
if ((value[0][i] - i) > (value[0][where] - where)) where = i;
}
for (int i = 0; i < r && where < n; ++i, where = f[where]) {
if (where == f[where]) break;
for (int j = where; j < f[where]; ++j) {
for (int k = 0; k < a[j] - 1; ++k) printf("%c", words[j][k]);
if (j == f[where] - 1)
printf("\n");
else
printf(" ");
}
}
return 1;
}
int main() {
srand(rdtsc());
while (1) {
if (!solve()) break;
exit(0);
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000000;
int main() {
int n, r, c;
static string a[MaxN];
cin >> n >> r >> c;
for (int i = 0; i < n; i++) cin >> a[i];
static int sumL[MaxN + 1];
sumL[0] = 0;
for (int i = 0; i < n; i++) sumL[i + 1] = sumL[i] + (int)a[i].size();
static int next[MaxN + 1];
for (int i = 0, j = 0; i < n; i++) {
if (j < i) j = i;
while (j < n && sumL[j + 1] - sumL[i] + j - i <= c) j++;
next[i] = j;
}
next[n] = n;
static int t[MaxN + 1];
static int go[MaxN + 1];
copy(next, next + n + 1, t);
for (int i = 0; i <= n; i++) go[i] = i;
for (int k = r; k > 0; k >>= 1) {
if (k & 1) {
for (int i = 0; i <= n; i++) go[i] = go[t[i]];
}
for (int i = 0; i <= n; i++) t[i] = t[t[i]];
}
int res = 0, resP = 0;
for (int i = 0; i < n; i++)
if (go[i] - i > res) res = go[i] - i, resP = i;
for (int i = resP; i != go[resP]; i = next[i]) {
for (int k = i; k < next[i]; k++) {
cout << a[k];
if (k + 1 < next[i])
cout << " ";
else
cout << endl;
}
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, R, C;
cin >> N >> R >> C;
vector<string> S(N);
for (int i = 0; i < N; ++i) cin >> S[i];
int p = -1;
int total = 0;
vector<vector<int> > next(32, vector<int>(N + 1, N));
for (int i = 0; i < N; ++i) {
if (p <= i) {
p = i;
total = 0;
} else {
total -= S[i - 1].size() + 1;
}
while (p < N and total + int(total > 0) + int(S[p].size()) <= C) {
total += S[p].size() + int(total > 0);
++p;
}
next[0][i] = p;
}
for (int i = 1; i < 32; ++i)
for (int j = 0; j < N; ++j) next[i][j] = next[i - 1][next[i - 1][j]];
int answer = -1, where = -1;
for (int i = 0; i < N; ++i) {
int k = i;
for (int j = 0; j < 31; ++j)
if ((1 << j) & R) k = next[j][k];
if (k - i > answer) {
answer = k - i;
where = i;
}
}
total = 0;
for (int i = where; i < where + answer; ++i) {
if (total + int(S[i].size()) + int(total > 0) > C) {
cout << "\n";
total = 0;
}
if (total > 0) cout << " ";
cout << S[i];
total += S[i].size() + int(total > 0);
}
cout << "\n";
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int a[1000005], nex[1000005], ans[1000005];
char s[6000005];
int n, r, c, t = 1;
void ksm(int x) {
if (!x) return;
ksm(x >> 1);
for (int i = 1; i <= n; i++) {
ans[i] = ans[ans[i]];
if (x & 1) ans[i] = nex[ans[i]];
}
}
int main() {
while (scanf("%d%d%d", &n, &r, &c) != EOF) {
a[1] = 0;
for (int i = 1; i <= n; i++)
scanf("%s", s + a[i]), a[i + 1] = a[i] + strlen(s + a[i]),
s[a[i + 1]++] = ' ';
for (int i = n + 1, j = n + 1; i; i--) {
while (a[j] - a[i] > c + 1) j--;
nex[ans[i] = i] = j;
}
ksm(r);
t = 1;
for (int i = 2; i <= n; i++)
if (ans[i] - i > ans[t] - t) t = i;
for (int i = 1; i <= r; i++, t = nex[t], puts(""))
for (int j = a[t]; j + 1 < a[nex[t]]; j++) putchar(s[j]);
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1E6 + 5;
int n, r, c, cur = -1, nxt[N];
bool chk[N];
pair<int, int> ans = {0, 0};
vector<int> ve, adj[N];
string s[N];
void DFS(int u) {
chk[u] = true;
ve.push_back(u);
ans = max(ans, {ve[max(0, (int)ve.size() - r - 1)] - u, u});
for (int &v : adj[u]) {
if (v != u) {
DFS(v);
}
}
ve.pop_back();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> r >> c;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = 0; i <= c; i++) {
s[n].push_back('0');
}
for (int i = 0, pt = 0; i <= n; i++) {
while (pt <= n && cur <= c) {
cur += s[pt++].size() + 1;
}
nxt[i] = pt - 1;
adj[pt - 1].push_back(i);
cur -= s[i].size() + 1;
}
for (int i = n; i >= 0; i--) {
if (!chk[i]) {
DFS(i);
}
}
for (int i = 0, cur = ans.second; i < r && cur < n && cur < nxt[cur];
i++, cur = nxt[cur]) {
for (int j = cur; j < nxt[cur] - 1; j++) {
cout << s[j] << " ";
}
cout << s[nxt[cur] - 1] << '\n';
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 7e6 + 10;
const int M = 1e6 + 10;
char s[N];
int word[N];
int f[M], st[M], a[M], buff[M], g[M];
int ret[M];
void power(int k, int n) {
for (int i = 0; i <= n; i++) ret[i] = i;
while (k) {
if (k & 1) {
for (int i = 0; i <= n; i++) buff[i] = ret[f[i]];
for (int i = 0; i <= n; i++) ret[i] = buff[i];
}
for (int i = 0; i <= n; i++) buff[i] = f[f[i]];
for (int i = 0; i <= n; i++) f[i] = buff[i];
k >>= 1;
}
}
int main() {
int n, r, c;
int curr = 0;
scanf("%d %d %d", &n, &r, &c);
for (int i = 0; i < n; i++) {
st[i] = curr;
scanf("%s", s + curr);
for (; s[curr]; curr++) {
word[curr] = i;
a[i]++;
}
word[curr] = i;
curr++;
}
f[n] = n;
for (int i = n - 1; i >= 0; i--) {
int nxt = st[i] + c;
if (nxt >= curr)
f[i] = n;
else if (s[nxt] == 0) {
f[i] = word[nxt] + 1;
} else
f[i] = word[nxt];
g[i] = f[i];
}
power(r, n);
int ans = 0;
int mxind = 0;
for (int i = 0; i < n; i++) {
if (ret[i] - i > ans) mxind = i;
ans = max(ans, ret[i] - i);
}
for (int i = mxind; i < mxind + ans;) {
for (int j = i; j < g[i]; j++) {
printf("%s", s + st[j]);
if (j != g[i] - 1) printf(" ");
}
printf("\n");
i = g[i];
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int A[1 << 20];
int S[1 << 20];
char buf[8 << 20];
int R[20][1 << 20];
string W[1 << 20];
int main() {
int n, r, c;
scanf("%d%d%d", &n, &r, &c);
++c;
int i, j;
for (i = (0); i < (n); ++i) {
scanf("%s", buf);
A[i] = strlen(buf) + 1;
W[i] = buf;
}
S[0] = 0;
for (i = (0); i < (n); ++i) S[i + 1] = S[i] + A[i];
int pos = 0;
for (i = (0); i < (n + 1); ++i) {
while (pos < n && S[pos + 1] - S[i] <= c) ++pos;
R[0][i] = pos;
}
for (i = (1); i < (20); ++i)
for (j = (0); j < (n + 1); ++j) R[i][j] = R[i - 1][R[i - 1][j]];
int res = -1;
pos = -1;
for (i = (0); i < (n); ++i) {
int t = i;
for (j = (0); j < (20); ++j)
if ((r & (1 << j)) != 0) t = R[j][t];
if (res < t - i) {
res = t - i;
pos = i;
}
}
for (i = (0); i < (r); ++i) {
int next = R[0][pos];
for (j = (pos); j < (next); ++j)
printf("%s%c", W[j].c_str(), j == next - 1 ? '\n' : ' ');
pos = next;
}
return 0;
};
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, r, c, x, ma, an1, an2, len;
int l[1000010], f[1000010][21], s[1000010], L[1000010], R[1000010];
char p[1000010 * 6];
int main() {
scanf("%d%d%d", &n, &r, &c);
for (i = 1; i <= n; i++) {
scanf("%s", p + len + 1);
l[i] = strlen(p + len + 1);
s[i] = s[i - 1] + l[i];
L[i] = len + 1;
len += l[i] + 1;
R[i] = len - 1;
}
j = n;
for (i = n; i; i--) {
for (; j >= i && s[j] - s[i - 1] + j - i > c; j--)
;
if (j >= i) f[i][0] = j;
}
for (i = 1; i <= 20; i++)
for (j = 1; j <= n; j++)
if (f[j][i - 1]) f[j][i] = max(f[f[j][i - 1] + 1][i - 1], f[j][i - 1]);
for (i = 1; i <= n; i++)
if (f[i][0]) {
for (k = r, x = i, j = 20; j >= 0; j--)
if (k >= (1 << j) && f[x][0]) x = f[x][j] + 1, k -= 1 << j;
if (x - i > ma) {
ma = x - i;
an1 = i, an2 = x - 1;
}
}
if (ma) {
k = -1;
for (i = an1; i <= an2; i++) {
if (k + l[i] + 1 > c) printf("\n"), k = -1;
if (k >= 0) printf(" ");
k += l[i] + 1;
for (j = L[i]; j <= R[i]; j++) printf("%c", p[j]);
}
printf("\n");
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1000005;
int n, r, c;
string words[NMAX];
int s_part[NMAX];
inline int space(int left, int right) {
return s_part[right] - s_part[left - 1] + right - left;
}
int dp[20][NMAX];
inline void precalc_dp() {
for (int i = 1; i <= n; ++i) {
int left = i;
int right = n;
int best = i - 1;
int middle;
while (left <= right) {
middle = (left + right) >> 1;
if (space(i, middle) <= c) {
best = middle;
left = middle + 1;
} else
right = middle - 1;
}
dp[0][i] = best;
}
int j;
for (int i = 1; (1 << i) <= n; ++i)
for (j = 1; j <= n; ++j)
if (dp[i - 1][j] + 1 > n)
dp[i][j] = n;
else
dp[i][j] = dp[i - 1][dp[i - 1][j] + 1];
}
int get_best(int pos) {
if (r > n) r = n;
int i = 0;
for (; (1 << i) <= r; ++i)
;
--i;
int where = pos - 1;
for (; i >= 0 && where < n; --i)
if (r & (1 << i)) where = dp[i][where + 1];
return where;
}
inline void print(int left, int right) {
cout << words[left];
int current = words[left].size();
for (int i = left + 1; i <= right; ++i) {
if (current + 1 + words[i].size() <= c) {
cout << ' ' << words[i];
current += (1 + words[i].size());
} else {
cout << '\n' << words[i];
current = words[i].size();
}
}
cout << '\n';
}
int main() {
ios_base ::sync_with_stdio(false);
cin >> n >> r >> c;
for (int i = 1; i <= n; ++i) cin >> words[i];
for (int i = 1; i <= n; ++i) s_part[i] = s_part[i - 1] + words[i].size();
precalc_dp();
int l_best = 0;
int where = 0;
int aux;
for (int i = 1; i <= n; ++i) {
aux = get_best(i);
if (aux - i + 1 > l_best) l_best = aux - i + 1, where = i;
}
if (l_best == 0) return 0;
print(where, where + l_best - 1);
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, r, c, a[N];
string s[N];
struct edge {
int to, nx;
} ee[N];
int eq[N], en = 1;
int root[N], sta[N], top;
int ss, tt;
void link(int u, int v) {
if (u == v)
root[u] = 1;
else
ee[++en] = (edge){v, eq[u]}, eq[u] = en;
}
void upd(int s, int t) {
if (t - s > tt - ss) {
ss = s;
tt = t;
}
}
void dfs(int go) {
sta[top = 1] = go;
while (top) {
int u = sta[top];
if (!eq[u]) {
int v = sta[max(top - r, 1)];
upd(u, v);
--top;
} else {
sta[++top] = ee[eq[u]].to;
eq[u] = ee[eq[u]].nx;
}
}
}
int main() {
scanf("%d %d %d", &n, &r, &c);
for (int i = 1; i <= n; ++i) {
cin >> s[i];
a[i] = s[i].length();
}
link(n + 1, n + 1);
for (int i = n, j = i, tot = 0; i >= 1; --i) {
tot += a[i] + (i != j);
while (tot > c) {
tot -= a[j] + (i != j);
--j;
}
link(j + 1, i);
}
for (int i = n + 1; i >= 1; --i) {
if (root[i]) dfs(i);
}
for (int i = ss, tot = 0; i < tt; ++i) {
if (tot + (tot > 0) + a[i] > c) {
putchar('\n');
tot = 0;
}
if (tot != 0) putchar(' ');
cout << s[i];
tot += (tot > 0) + a[i];
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
const int inf = 1039074182;
using namespace std;
int n, r, c;
string word[1000005];
int len[1000005];
int nxt[1000005];
pair<int, int> st[1000005][22];
int sum[1000005];
int calc(int start) {
int res = 0;
for (int i = 0; i < 22; i++) {
if ((1 << i) & r) {
res += st[start][i].second;
start = st[start][i].first;
}
}
return res;
}
void print(int start) {
for (int i = 0; i < r; i++) {
if (start == n) break;
for (int j = start; j < nxt[start]; j++) {
cout << word[j];
if (j != nxt[start] - 1) cout << ' ';
}
cout << endl;
start = nxt[start];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> r >> c;
for (int i = 0; i < n; i++) {
cin >> word[i];
len[i] = word[i].size();
}
sum[0] = len[0] + 1;
for (int i = 1; i < n; i++) {
sum[i] = sum[i - 1] + len[i] + 1;
}
for (int i = 0, j = 0; i < n; i++) {
while (j < n && sum[j] - (i ? sum[i - 1] : 0) - 1 <= c) j++;
nxt[i] = j;
}
for (int i = 0; i < n; i++) {
st[i][0] = make_pair(nxt[i], nxt[i] - i);
}
for (int i = 0; i < 22; i++) {
st[n][i] = make_pair(n, 0);
}
for (int k = 1; k < 22; k++) {
for (int i = 0; i < n; i++) {
st[i][k].first = st[st[i][k - 1].first][k - 1].first;
st[i][k].second =
st[i][k - 1].second + st[st[i][k - 1].first][k - 1].second;
}
}
int res = -1, maxk = -1;
int temp;
for (int i = 0; i < n; i++) {
temp = calc(i);
if (temp > res) {
res = temp;
maxk = i;
}
}
print(maxk);
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
int n, nr, nc, a[1 << 20];
int d[20][1 << 20];
char *s[1 << 20], buf[6 << 20];
int main() {
scanf("%d%d%d", &n, &nr, &nc);
{
int i, j, sum;
int best = -1, bi;
nc += 2;
for (i = j = 0; i < n; ++i) {
scanf(" %s", s[i] = buf + j);
j += a[i] = strlen(buf + j) + 1;
}
for (sum = i = j = 0; i < n; sum -= a[i++]) {
while (j < n && sum + a[j] < nc) sum += a[j++];
d[0][i] = j;
}
d[0][n] = n;
for (i = 0; ++i < 20;)
for (j = 0; j <= n; ++j) d[i][j] = d[i - 1][d[i - 1][j]];
for (i = 0; i < n; ++i) {
int t = nr, next = i;
for (j = 0; t; ++j, t >>= 1)
if (t & 1) next = d[j][next];
if (best < 0 || best < next - i) {
best = next - i;
bi = i;
}
}
best += bi;
for (sum = 0, i = bi, j = 0; i < best; ++i) {
if (sum + a[i] >= nc) {
puts("");
++j;
sum = 0;
}
printf(" %s" + !sum, s[i]);
sum += a[i];
}
puts("");
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int n, r, c, num[1000010][30], sum[1000010], mx = 0, sta;
string s[1000010];
vector<vector<string> > ans;
vector<string> t;
bool check(int mid, int i) {
return sum[i + mid - 1] - sum[i - 1] + mid - 1 <= c;
}
int main() {
cin >> n >> r >> c;
for (int i = 1; i <= n; i++) {
cin >> s[i];
sum[i] = sum[i - 1] + s[i].size();
}
for (int i = 1; i <= n; i++) {
int lb = 0, ub = n - i + 1, mid;
while (lb < ub) {
mid = (lb + ub + 1) / 2;
if (check(mid, i))
lb = mid;
else
ub = mid - 1;
}
num[i][0] = lb;
}
for (int i = 1; i <= 22; i++)
for (int j = 1; j <= n; j++)
num[j][i] = num[j][i - 1] + num[j + num[j][i - 1]][i - 1];
for (int i = 1; i <= n; i++) {
int tmp = r, cc = 0, now = i;
while (tmp > 0) {
if (tmp % 2 == 1) now += num[now][cc];
cc++;
tmp /= 2;
}
now--;
if (mx < now - i + 1) {
mx = now - i + 1;
sta = i;
}
}
int len = -1;
for (int i = sta; i < sta + mx; i++) {
if (len + s[i].size() + 1 > c) {
ans.push_back(t);
t.clear();
t.push_back(s[i]);
len = s[i].size();
} else {
len += s[i].size() + 1;
t.push_back(s[i]);
}
}
ans.push_back(t);
for (int i = 0; i < ans.size(); i++) {
for (int j = 0; j < ans[i].size(); j++) {
cout << ans[i][j];
if (j < ans[i].size() - 1) cout << ' ';
}
cout << endl;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int n, m, s;
string a[N + 1];
int Sum[N + 1];
vector<int> son[N + 2];
int fa[N + 2];
int stk[N + 1], top;
int ans[N + 2];
void dfs(int x) {
stk[top++] = x;
ans[x] = stk[max(0, top - 1 - s)] - x;
for (int i = 0; i < son[x].size(); i++) {
int y = son[x][i];
dfs(y);
}
top--;
}
int main() {
cin >> n >> s >> m;
for (int i = 1; i <= n; i++)
cin >> a[i], Sum[i] = Sum[i - 1] + a[i].size() + 1;
fa[n + 1] = n + 1;
for (int i = n; i; i--) {
fa[i] = fa[i + 1];
while (Sum[fa[i] - 1] - Sum[i - 1] - 1 > m) fa[i]--;
if (fa[i] != i) son[fa[i]].push_back(i);
}
for (int i = 1; i <= n + 1; i++)
if (fa[i] == i) top = 0, dfs(i);
int mx = *max_element(ans + 1, ans + n + 2);
for (int i = 1; i <= n + 1; i++)
if (ans[i] == mx) {
while (s--) {
for (int j = i; j < fa[i]; j++)
cout << a[j] << (j < fa[i] - 1 ? " " : "");
puts("");
i = fa[i];
}
return 0;
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int a[N], nex[N], ans[N], n, r, c, t = 1;
char s[6 * N];
void dfs(int x) {
if (!x) return;
dfs(x >> 1);
for (int i = 1; i <= n; i++) {
ans[i] = ans[ans[i]];
if (x & 1) ans[i] = nex[ans[i]];
}
}
int main() {
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; i++) {
scanf("%s", s + a[i]);
a[i + 1] = a[i] + strlen(s + a[i]);
s[a[i + 1]++] = ' ';
}
for (int i = n + 1, j = n + 1; i; i--) {
while (a[j] - a[i] > c + 1) j--;
nex[ans[i] = i] = j;
}
dfs(r);
for (int i = 2; i <= n; i++)
if (ans[i] - i > ans[t] - t) t = i;
for (int i = 1; i <= r; i++, t = nex[t], puts(""))
for (int j = a[t]; j + 1 < a[nex[t]]; j++) putchar(s[j]);
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
string s[1000002];
int n, c, r, cnt[1000002], fa[1000002], top, a[1000002], ans[1000002],
vis[1000002];
vector<int> v[1000002];
void dfs(int x) {
a[top++] = x;
vis[x] = 1;
ans[x] = a[max(0, top - 1 - r)] - x;
for (int i = 0; i < v[x].size(); i++)
if (!vis[v[x][i]]) dfs(v[x][i]);
top--;
}
int main() {
cin >> n >> r >> c;
for (int i = 0; i < n; i++) cin >> s[i];
int cc = 0;
int j = 0;
for (int i = 0; i <= n; i++) {
if (s[i].size() > c)
j = i + 1, fa[i] = i, cc = 0;
else {
for (j; j < n && cc <= c + 1; j++) cc += (s[j].size() + 1);
fa[i] = j - (cc > c + 1);
cc -= (s[i].size() + 1);
}
if (fa[i] != i) v[fa[i]].push_back(i);
}
for (int i = 0; i <= n; i++)
if (fa[i] == i) top = 0, dfs(i);
int maxn = 0;
for (int i = 0; i <= n; i++) maxn = max(maxn, ans[i]);
for (int i = 0; i < n; i++)
if (ans[i] == maxn && s[i].size() <= c) {
for (j = 0; j < r; j++) {
int cc = 0;
for (; i < n && cc + s[i].size() + 1 <= c + 1; i++) {
cc += s[i].size() + 1, cout << s[i];
if (cc < c) cout << ' ';
}
cout << endl;
}
return 0;
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int wordAt[7000007];
int nextR[1000007];
int dyn[30][1000007];
int main() {
int N, R, C;
scanf("%d %d %d ", &N, &R, &C);
;
string line;
getline(cin, line);
int len = line.size();
int w = 0;
for (int i = (0); i < (len); i++) {
if (line[i] == ' ') w++;
wordAt[i] = w;
}
int last = -1;
bool next = true;
w = 0;
for (int i = (0); i < (len); i++) {
if (next) {
if (i + C >= len)
nextR[w] = N;
else
nextR[w] = wordAt[i + C];
w++;
next = false;
}
if (line[i] == ' ') next = true;
}
nextR[N] = N;
for (int i = (0); i < (N + 1); i++) dyn[0][i] = nextR[i];
for (int d = (1); d < (30); d++) {
for (int i = (0); i < (N + 1); i++) {
dyn[d][i] = dyn[d - 1][dyn[d - 1][i]];
}
}
int best = 0;
int bestAt = 0;
for (int i = (0); i < (N); i++) {
int ro = R;
int d = 0;
int msk = 1;
int at = i;
while (ro) {
if (ro & msk) {
at = dyn[d][at];
ro -= msk;
}
msk <<= 1;
d++;
}
int cnt = at - i;
if (cnt > best) {
best = cnt;
bestAt = i;
}
}
int atW = bestAt;
int atCh = 0;
while (wordAt[atCh] != bestAt) atCh++;
if (line[atCh] == ' ') atCh++;
for (int i = (0); i < (R); i++) {
int wr = nextR[atW];
while (atCh < len && wordAt[atCh] != wr) printf("%c", line[atCh++]);
;
if (line[atCh] == ' ') atCh++;
atW = wr;
printf("\n");
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
string str[1000006];
int dp[22][1000006];
int l[1000006];
int main() {
int n, r, c, i, j, k;
cin >> n >> r >> c;
for (i = 0; i < (n); i++) {
cin >> str[i];
l[i] = ((int)(str[i]).size());
if (i) l[i] += l[i - 1];
}
j = 0;
for (i = 0; i < (n); i++) {
for (; j < n; j++) {
if ((l[j] - ((i != 0) ? l[i - 1] : 0) + (j - i)) > c) break;
}
dp[0][i] = j - 1;
}
for (i = (1); i <= (21); i++) {
for (j = 0; j < (n); j++) {
dp[i][j] =
dp[i - 1]
[((dp[i - 1][j] + 1) < (n - 1) ? (dp[i - 1][j] + 1) : (n - 1))];
}
}
vector<int> v;
for (i = 0; i < (30); i++)
if (r & (1 << i)) v.push_back(i);
reverse((v).begin(), (v).end());
int ans = -1;
int id = 0;
for (i = 0; i < (n); i++) {
j = i - 1;
for (k = 0; k < (((int)(v).size())); k++)
j = dp[v[k]][((n - 1) < (j + 1) ? (n - 1) : (j + 1))];
if (ans < (j - i + 1)) {
ans = (j - i + 1);
id = i;
}
}
int l = 0, f = 1;
for (i = 0; i < ans; i++) {
j = ((int)(str[id + i]).size());
l += j;
if (i) l++;
if (l > c) {
cout << endl;
l = j;
}
if (j != l) {
cout << " ";
}
cout << str[id + i];
}
cout << endl;
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e6 + 6;
int n, r, c, t = 1, fr[mxn], nxt[mxn], ans[mxn];
char s[6 * mxn];
inline void make(int x) {
if (!x) return;
make(x >> 1);
for (int i = 1; i <= n; ++i) {
ans[i] = ans[ans[i]];
if (x & 1) ans[i] = nxt[ans[i]];
}
}
int main() {
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; ++i) {
scanf("%s", s + fr[i]);
fr[i + 1] = fr[i] + strlen(s + fr[i]);
s[fr[i + 1]++] = ' ';
}
for (int i = n + 1, j = n + 1; i; nxt[ans[i] = i] = j, --i)
for (; fr[j] - fr[i] > c + 1; --j)
;
make(r);
for (int i = 2; i <= n; ++i)
if (ans[i] - i > ans[t] - t) t = i;
for (int i = 1; i <= r; ++i, t = nxt[t], putchar('\n'))
for (int j = fr[t]; j + 1 < fr[nxt[t]]; j++) putchar(s[j]);
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const int LOG = 20 + 2;
int n, row, c;
string s[MAXN];
int ri[LOG][MAXN];
int get(int ind) {
int x = row, tind = ind;
for (int i = LOG - 1; i >= 0; i--)
if (x >= (1 << i)) {
x -= (1 << i);
ind = ri[i][ind];
}
return ind - tind;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> row >> c;
for (int i = 0; i < n; i++) cin >> s[i];
{
int r = 0, sz = 0;
for (int i = 0; i < n; i++) {
if (r < i) r = i;
while (r < n && sz + 1 * bool(sz) + (int)s[r].size() <= c)
sz += 1 * bool(sz) + (int)s[r++].size();
ri[0][i] = r;
if (r > i) sz = max(0, sz - (1 + (int)s[i].size()));
}
}
for (int i = 1; i < LOG; i++) {
ri[i - 1][n] = n;
for (int j = 0; j < n; j++) ri[i][j] = ri[i - 1][ri[i - 1][j]];
}
int ans = 0, ind = -1;
for (int i = 0; i < n; i++) {
int sz = get(i);
if (sz > ans) {
ans = sz;
ind = i;
}
}
if (ind >= 0) {
int i = ind;
while (i < ind + ans) {
for (int j = i; j < ri[0][i]; j++)
if (j != ri[0][i] - 1)
cout << s[j] << " ";
else
cout << s[j] << "\n";
i = ri[0][i];
}
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int M = 5000005, N = 1000005;
int n, i, w, h, pe, k, j, L, st, erk, b, res, rx, a[N], t[N], d[N];
int as, p[N][23], qa, in, q[N][23];
char c[M];
vector<char> s[N];
vector<int> ma[N];
int main() {
scanf("%d%d%d", &n, &h, &w);
w++;
for (i = 1; i <= n; ++i) {
c[0] = '\0';
scanf("%s", c);
pe = strlen(c);
for (j = 0; j < pe; ++j) {
s[i].push_back(c[j]);
}
a[i] = pe + 1;
}
for (i = 1; i <= n; ++i) {
d[i] = a[i] + d[i - 1];
}
st = 0;
for (i = 1; i <= n; ++i) {
while (d[i] - d[st] > w) {
st++;
}
t[i] = st;
}
as = 1;
while (as < n) {
as = as * 2;
L++;
}
for (i = 1; i <= n; ++i) {
p[i][0] = t[i];
q[i][0] = 1;
if (i == t[i]) q[i][0] = 0;
for (j = 1; j <= L; ++j) {
p[i][j] = p[p[i][j - 1]][j - 1];
q[i][j] = q[i][j - 1] + q[p[i][j - 1]][j - 1];
}
}
res = 0;
rx = 0;
for (i = 1; i <= n; ++i) {
b = i;
erk = 0;
for (j = L; j >= 0; --j) {
if (erk + q[b][j] <= h) {
erk = erk + q[b][j];
b = p[b][j];
}
}
if (i - b > res) {
res = i - b;
rx = i;
}
}
if (rx != 0) {
qa = 0;
for (i = rx;; i = t[i]) {
if (i == t[i] || qa == h) break;
qa++;
for (j = t[i] + 1; j <= i; ++j) {
ma[qa].push_back(j);
}
}
}
for (i = qa; i >= 1; --i) {
in = ma[i][0];
for (k = 0; k < s[in].size(); ++k) {
printf("%c", s[in][k]);
}
for (j = 1; j < ma[i].size(); ++j) {
in = ma[i][j];
printf(" ");
for (k = 0; k < s[in].size(); ++k) {
printf("%c", s[in][k]);
}
}
printf("\n");
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int tmp[5000000 + 5], a[5000000 + 5], p[5000000 + 5], n, r, c, ans[5000000 + 5],
k[5000000 + 5], cnt = 0, w[5000000 + 5][2];
char s[2 * 5000000 + 5];
void multy(int *a, int *b) {
for (int i = 0; i <= n + 1; i++) k[i] = b[a[i]];
for (int i = 0; i <= n + 1; i++) a[i] = k[i];
}
int main() {
scanf("%d%d%d", &n, &r, &c);
getchar();
gets(s);
cnt = 1;
int l = strlen(s);
for (int i = 0; i <= l; i++)
if (i == l || s[i] == ' ') w[cnt][1] = i, w[++cnt][0] = i + 1;
for (int i = 1, j = 0; i <= n; i++) {
while (j <= n && w[j][1] - w[i][0] <= c) j++;
if (j <= i)
p[i] = j = i;
else
p[i] = j;
}
p[n + 1] = n + 1;
for (int i = 0; i <= n + 1; i++) ans[i] = i, tmp[i] = p[i];
while (r) {
if (r & 1) multy(ans, tmp);
multy(tmp, tmp), r >>= 1;
}
int mx = 0;
for (int i = 1; i <= n; i++)
if (ans[i] - i > ans[mx] - mx) mx = i;
int now = mx;
while (now < ans[mx]) {
for (int i = w[now][0]; i < w[p[now] - 1][1]; i++) putchar(s[i]);
puts("");
now = p[now];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
int n, r, c;
string str[maxn];
int len[maxn];
int sum[maxn + 1];
int jump[maxn], res[maxn];
void Tran(const int *a, const int *b, int *c) {
static int tmp[maxn];
for (int i = 0; i < n; ++i) {
tmp[i] = a[i] == n ? n : b[a[i]];
}
copy(tmp, tmp + n, c);
}
int main(void) {
scanf("%d%d%d", &n, &r, &c);
for (int i = 0; i < n; ++i) {
cin >> str[i];
len[i] = str[i].length();
sum[i + 1] = sum[i] + len[i];
}
for (int i = 0; i < n; ++i) {
int low = i, high = n + 1;
while (high - low > 1) {
int mid = low + high >> 1;
if (sum[mid] - sum[i] + (mid - i - 1) <= c) {
low = mid;
} else {
high = mid;
}
}
jump[i] = low;
}
for (int i = 0; i < n; ++i) {
res[i] = i;
}
for (int y = r; y; y >>= 1) {
if (y & 1) Tran(res, jump, res);
Tran(jump, jump, jump);
}
int best = 0;
for (int i = 1; i < n; ++i) {
if (res[i] - i > res[best] - best) {
best = i;
}
}
for (int i = 0; i < r; ++i) {
int rest = c + 1;
while (best < n && len[best] < rest) {
if (rest < c + 1) putchar(' ');
rest -= len[best] + 1;
printf("%s", str[best].c_str());
++best;
}
putchar('\n');
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
char s[1000005 * 6];
int n, m, c;
int f[1000005][22];
int a[1000005];
int st, mx;
int calc(int x) {
int tot = m;
for (int i = 20; i >= 0; i--) {
if (tot >= (1 << i)) {
x = f[x][i];
tot -= (1 << i);
}
}
return x;
}
int main() {
scanf("%d%d%d", &n, &m, &c);
for (int i = 1; i <= n; i++) {
scanf("%s", s + a[i]);
a[i + 1] = a[i] + strlen(s + a[i]);
s[a[i + 1]++] = ' ';
}
int wz = 1;
for (int i = 1; i <= n; i++) {
while (wz <= n && a[wz + 1] - 2 - a[i] + 1 <= c) wz++;
f[i][0] = wz;
}
f[n + 1][0] = n + 1;
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= n + 1; j++) f[j][i] = f[f[j][i - 1]][i - 1];
for (int i = 1; i <= n; i++) {
int nt = calc(i);
if (nt - i > mx) {
mx = nt - i;
wz = i;
}
}
for (int i = 1; i <= m; i++) {
if (wz == n + 1) break;
int nt = f[wz][0];
if (nt != wz) {
for (int j = a[wz]; j <= a[nt] - 2; j++) putchar(s[j]);
puts("");
wz = nt;
}
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
int N, R, C;
int A[MAXN], MR[MAXN];
string s[MAXN];
int mt[MAXN], mlv[MAXN][20];
void printAd(int x) {
int i, j;
for (i = 1; i <= R; i++) {
for (j = x; j <= mt[x] - 1; j++) {
if (j != x) putchar(' ');
cout << s[j];
}
cout << endl;
x = mt[x];
if (x > N) break;
}
}
int main() {
scanf("%d%d%d", &N, &R, &C);
int i, k;
for (i = 1; i <= N; i++) {
cin >> s[i];
A[i] = s[i].size() + 1;
}
int Sum = -1, r = 1;
for (i = 1; i <= N; i++) {
while ((r <= N) && (Sum + A[r] <= C)) Sum += A[r++];
mt[i] = r;
Sum -= A[i];
}
mt[N + 1] = N + 1;
for (i = 1; i <= N + 1; i++) mlv[i][0] = mt[i];
for (k = 1; k <= 19; k++)
for (i = 1; i <= N + 1; i++) mlv[i][k] = mlv[mlv[i][k - 1]][k - 1];
int ans = 0;
for (i = 1; i <= N; i++) {
MR[i] = i;
for (int t = R; t; t -= (t & -t)) MR[i] = mlv[MR[i]][__builtin_ctz(t)];
ans = max(ans, MR[i] - i);
}
for (i = 1; i <= N; i++)
if (ans == MR[i] - i) {
printAd(i);
return 0;
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, r, c;
string str[1000005];
int l[1000005];
int nex[1000005][22];
int main() {
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; i++) {
cin >> str[i];
l[i] = str[i].size();
}
int q = 1;
int sz = -1;
for (int i = 1; i <= n; sz -= 1 + l[i++]) {
if (q < i) sz = -1, q = i;
while (q <= n && sz + 1 + l[q] <= c) sz += 1 + l[q++];
nex[i][0] = q;
}
nex[n + 1][0] = n + 1;
for (int j = 1; j <= 21; j++)
for (int i = 1; i <= n + 1; i++) nex[i][j] = nex[nex[i][j - 1]][j - 1];
int ans = 0, st;
for (int i = 1; i <= n; i++) {
int p = i;
for (int j = 0; j <= 21; j++)
if (1 << j & r) p = nex[p][j];
if (p - i > ans) {
ans = p - i;
st = i;
}
}
if (ans) {
int e;
for (int i = 1; i <= r; i++) {
e = nex[st][0];
for (int j = st; j < e; j++) {
if (j > st) putchar(' ');
cout << str[j];
}
st = e;
printf("\n");
}
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
#pragma GCC optimization("O3")
using namespace std;
template <typename T>
inline void Cin(T& first) {
char c;
T sign = 1;
first = 0;
for (c = getchar(); c < '0' || c > '9'; c = getchar())
if (c == '-') sign = -1;
for (; c >= '0' && c <= '9'; c = getchar()) first = first * 10 + c - '0';
first *= sign;
}
template <typename T>
inline void Out(T first) {
if (first > 9) Out(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void Cout(T first, char c) {
if (first < 0) putchar('-');
first = abs(first);
Out(first);
putchar(c);
}
template <typename T, typename... Args>
inline void Cin(T& a, Args&... args) {
Cin(a);
Cin(args...);
}
template <typename T, typename... Args>
inline void Cout(T a, char c, Args... args) {
Cout(a, c);
Cout(args...);
}
const int N = int(1e6) + 7;
const int logN = 20;
int n, sum, r, c, a[N], p[N][logN];
string s, _s[N];
void Enter() {
cin >> n >> r >> c;
cin.ignore();
getline(cin, s);
int ptr = 1;
for (char c : s) {
if (c == ' ')
a[ptr] = int(_s[ptr].size()), ++ptr;
else
_s[ptr] += c;
}
a[ptr] = _s[ptr].size();
ptr = 1;
for (int i = 1; i <= n; ++i) {
sum -= (a[i - 1] + 1);
if (ptr <= i || i == 1) sum = a[i], ptr = i;
while (sum <= c && ptr <= n) sum += 1 + a[++ptr];
p[i][0] = ptr;
}
for (int j = 1; j < logN; ++j) {
for (int i = 1; i <= n; ++i) p[i][j] = p[p[i][j - 1]][j - 1];
}
}
int Irene(int first) {
int old = first;
for (int i = logN - 1; i >= 0; --i)
if ((r >> i) & 1) first = p[first][i];
return first - old;
}
void Solve() {
int pos = 1, Max = 0, t;
for (int i = 1; i <= n; ++i) {
if ((t = Irene(i)) > Max) Max = t, pos = i;
}
for (int i = logN - 1; i >= 0; --i) {
if ((r >> i) & 1) {
for (int j = 0; j < (1 << i); ++j) {
for (int k = pos; k < p[pos][0]; ++k)
cout << _s[k] << " \n"[k == p[pos][0] - 1];
pos = p[pos][0];
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("test"
".inp",
"r")) {
freopen(
"test"
".inp",
"r", stdin);
freopen(
"test"
".out",
"w", stdout);
}
Enter(), Solve();
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, r, c, a[N], nxt[N][21];
string s[N];
int get_idx(int cur) {
int res = cur;
for (int i = 20; i >= 0; i--) {
if (((r >> i) & 1) == 1) {
res = nxt[res][i];
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> r >> c;
for (int i = 1; i <= n; i++) {
cin >> s[i];
a[i] = ((int)(s[i]).size());
}
int p = 0;
int cur = 0;
int cnt = 0;
nxt[n + 1][0] = n + 1;
for (int i = 1; i <= n; i++) {
while (p <= n && cur + cnt - 1 <= c) {
cur += a[++p];
cnt++;
}
nxt[i][0] = p;
cur -= a[i];
cnt--;
}
for (int j = 1; j <= 20; j++) {
for (int i = 1; i <= n + 1; i++) {
nxt[i][j] = nxt[nxt[i][j - 1]][j - 1];
}
}
int mx = 0;
p = -1;
for (int i = 1; i <= n; i++) {
int j = get_idx(i);
if (i == j) {
continue;
}
if (j - i > mx) {
mx = j - i;
p = i;
}
}
cur = 1;
for (int i = p; i <= p + mx - 1;) {
if (cur > r) {
break;
}
int cur_length = ((int)(s[i]).size());
cout << s[i++];
while (i <= p + mx - 1) {
if ((cur_length + 1 + ((int)(s[i]).size())) > c) {
break;
}
cur_length += 1 + ((int)(s[i]).size());
cout << " " << s[i++];
}
cout << "\n";
cur++;
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, r, c, len[N], ans[N][20], opt[N];
string s[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r >> c;
for (int i = (0); i < (n); i++) {
cin >> s[i];
len[i] = s[i].length();
}
int j = 0, L = -1;
ans[n][0] = n;
for (int i = (0); i < (n); i++) {
while (j < n && L + len[j] + 1 <= c) {
L += len[j] + 1;
j++;
}
ans[i][0] = j;
if (r & 1) {
opt[i] = j;
} else {
opt[i] = i;
}
L -= len[i] + 1;
}
for (int l = (1); l < (20); l++) {
for (int i = (0); i < (n); i++) {
ans[i][l] = ans[ans[i][l - 1]][l - 1];
}
ans[n][l] = n;
if ((r >> l) & 1) {
for (int i = (0); i < (n); i++) {
opt[i] = ans[opt[i]][l];
}
}
}
int mx = -1, idx = 0;
for (int i = (0); i < (n); i++) {
if (opt[i] - i > mx) {
mx = opt[i] - i;
idx = i;
}
}
for (int i = (0); i < (r); i++) {
for (int j = (idx); j < (ans[idx][0]); j++) {
cout << s[j];
if (j < ans[idx][0] - 1) cout << ' ';
}
cout << '\n';
idx = ans[idx][0];
if (ans[idx][0] == idx) break;
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, R, C, ans, st;
string s[N];
int a[N], sum[N];
int p[22][N];
int t[22][N];
int main() {
scanf("%d%d%d", &n, &R, &C);
for (int i = 1; i <= n; i++) {
cin >> s[i];
a[i] = s[i].size();
}
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; i++) {
int l = i - 1, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (sum[mid] - sum[i - 1] + mid - i <= C)
l = mid + 1;
else
r = mid - 1;
}
p[0][i] = l;
}
p[0][n + 1] = n + 1;
for (int i = 0; i < 21; i++)
for (int j = 1; j <= n + 1; j++) p[i + 1][j] = p[i][p[i][j]];
for (int i = 1; i <= n; i++) {
int x = i;
for (int j = 0; j < 21; j++)
if (R & (1 << j)) x = p[j][x];
if (ans < x - i) {
ans = x - i;
st = i;
}
}
for (int i = 1; i <= R; i++) {
for (int j = st; j < p[0][st]; j++) {
printf("%s", s[j].c_str());
if (j + 1 != p[0][st]) printf(" ");
}
puts("");
st = p[0][st];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
char tt[5000010];
int n, R, C, s[1000010], f[20][1000010], len[1000010];
string S[1000010];
int Get(int x) {
int ans = 0;
while (x >> 1) {
ans++;
x >>= 1;
}
return ans;
}
void read(int &x) {
char ch = getchar();
int mark = 1;
for (; ch != '-' && (ch < '0' || ch > '9'); ch = getchar())
;
if (ch == '-') mark = -1, ch = getchar();
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - 48;
x *= mark;
}
void print(int x, bool mk) {
for (int i = 0; i < S[x].size(); i++) printf("%c", S[x][i]);
if (mk)
printf("\n");
else
printf(" ");
}
int main() {
read(n);
read(R);
read(C);
C++;
for (int i = 1; i <= n; i++) {
scanf("%s", tt);
S[i].assign(tt);
len[i] = S[i].size() + 1;
}
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + len[i];
int end = n + 1, st;
for (int i = n; i; i--) {
while (s[end - 1] - s[i - 1] > C) end--;
f[0][i] = end;
}
R = min(n, R);
int t = Get(R);
for (int i = 1; i <= t; i++)
for (int j = 1; j <= n; j++) f[i][j] = f[i - 1][f[i - 1][j]];
int ans = 0;
for (int i = 1; i <= n; i++) {
int u = i, rr = min(R, n - i + 1);
for (int j = 0; j <= t; j++)
if ((rr >> j) & 1) u = f[j][u];
if (u == 0) u = n + 1;
if (ans < u - i) ans = u - i, st = i;
}
if (ans) {
int t = 0;
for (int i = st; i <= st + ans - 1; i++) {
t += len[i];
if (t > C) t = len[i];
print(i, (i == st + ans - 1) || (len[i + 1] + t > C));
}
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int UNDEF = -1;
const long long INF = 1e18;
template <typename T>
inline bool chkmax(T &aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T &aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
int rint();
char rch();
long long rlong();
const int mn = 1e6 + 2;
string s[mn];
int p2w[6 * mn];
int w2p[mn];
int rr[mn];
vector<int> r2l[mn];
vector<vector<int> > v[mn];
bool cmp(const int &x, const int &y) {
return v[rr[x]].size() > v[rr[y]].size();
}
int main() {
int n, rows, cols;
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> rows >> cols;
for (int i = 1; i <= n; i++) cin >> s[i];
int alen = 0;
{
int sidx = 0;
for (int wi = 1; wi <= n; wi++) {
w2p[wi] = sidx;
int slen = s[wi].length();
for (int i = 0; i < slen; i++) {
p2w[sidx] = wi;
sidx++;
}
p2w[sidx] = wi + 1;
sidx++;
}
alen = sidx;
}
for (int wi = 1; wi <= n; wi++) {
int spos = w2p[wi];
int epos = spos + cols;
int r = n + 1;
if (epos < alen) r = p2w[epos];
int l = wi;
if (r > l) {
r2l[r].push_back(l);
}
}
for (int x = 0; x <= n + 1; x++) rr[x] = x;
int bestsz = -1, bestl = 1;
for (int r = 1; r <= n + 1; r++) {
int sz = r2l[r].size();
if (sz > 0) {
sort(r2l[r].begin(), r2l[r].end(), cmp);
rr[r] = rr[r2l[r][0]];
}
auto &vr = v[rr[r]];
vector<int> tmp;
tmp.push_back(r);
vr.push_back(tmp);
int rsz = vr.size();
int rslo = rsz - 1 - rows;
int rslo0 = max(0, rslo);
for (int li = 1; li < sz; li++) {
int l = r2l[r][li];
auto &vl = v[rr[l]];
int lsz = vl.size();
for (int ls = lsz - 1, rs = rsz - 2; ls >= 0 && rs >= rslo0; ls--, rs--) {
for (auto &w : vl[ls]) {
vr[rs].push_back(w);
}
}
}
if (r != n + 1 && s[r].length() <= cols) {
if (rslo >= 0) {
for (auto &l : vr[rslo]) {
int candsz = r - l;
if (candsz > bestsz) {
bestsz = candsz;
bestl = l;
}
}
}
} else {
for (int rs = rslo0; rs < rsz; rs++) {
for (auto &l : vr[rs]) {
int candsz = r - l;
if (candsz > bestsz) {
bestsz = candsz;
bestl = l;
}
}
}
}
}
while (rows--) {
int c = -1;
while (bestl <= n) {
int slen = 1 + s[bestl].length();
if (c + slen > cols) {
break;
}
if (c != -1) printf(" ");
c += slen;
printf("%s", s[bestl].c_str());
bestl++;
}
printf("\n");
}
}
static char stdinBuffer[1024];
static char *stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char *stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int rint() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char rch() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
long long rlong() {
readAhead(32);
long long x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int B = 6555555, BB = 1111111;
char s[B];
int a[BB], sum[BB], len[BB], tmp[BB], ans, r, cnt, ansv[BB], vst[BB];
vector<int> adj[BB];
void dfs(int u, int fa, int dp = -1) {
vst[u] = 1;
tmp[++dp] = u;
if (dp) {
len[dp] = len[dp - 1] + fa - u;
if (ans < len[dp] - len[max(0, dp - r)]) {
ans = len[dp] - len[max(0, dp - r)];
cnt = max(0, dp - r);
int t = 0;
for (int i = dp; i >= cnt; i--) ansv[t++] = tmp[i];
cnt = dp - cnt;
}
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (vst[v]) continue;
dfs(v, u, dp);
}
}
char *ss[BB];
void solve_B() {
int n, c;
gn(n, r, c);
c++;
gets(s);
char *p = strtok(s, " ");
n = 1;
while (p) {
ss[n] = p;
a[n++] = strlen(p) + 1;
p = strtok(NULL, " ");
}
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + a[i];
int pos = 1;
for (int i = 1; i < n; i++) {
smax(pos, i);
while (pos < n && sum[pos] - sum[i - 1] <= c) pos++;
if (pos > i) adj[pos].push_back(i);
}
for (int i = n + 1; i > 0; i--)
if (!vst[i]) dfs(i, i);
for (int i = 0; i < cnt; i++) {
for (int j = ansv[i]; j < ansv[i + 1] - 1; j++) printf("%s ", ss[j]);
printf("%s\n", ss[ansv[i + 1] - 1]);
}
}
int main() {
solve_B();
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int NN = 1000100;
char s[NN * 7];
int nxt[NN][21], len[NN], tot[NN];
int st[NN];
int main() {
int n, r, c, cur = 0;
gn(n, r, c);
for (int i = 1; i <= n; i++) {
scanf("%s", s + cur);
st[i] = cur;
len[i] = strlen(s + cur);
cur += len[i];
tot[i] = tot[i - 1] + len[i];
}
for (int i = 1; i <= n; i++) {
int j = max(i, nxt[i - 1][0]);
while (j <= n && tot[j] - tot[i - 1] + j - i <= c) j++;
nxt[i][0] = j;
}
for (int i = 0; i < 21; i++) nxt[n + 1][i] = n + 1;
for (int i = 1; i < 21; i++)
for (int j = 1; j <= n; j++) {
nxt[j][i] = nxt[nxt[j][i - 1]][i - 1];
}
int ans = 0, st = 0, ed = 0;
for (int i = 1; i <= n; i++) {
int k = r, u = i;
while (k) u = nxt[u][(__builtin_ctz(k))], k ^= k & -k;
if (u - i > ans) ans = u - i, st = i, ed = u;
}
if (!ans) return 0;
int pre = 0;
for (int i = st; i < ed; i++) {
if (pre + len[i] > c) pre = 0, puts("");
if (pre) putchar(' ');
for (int j = 0; j < len[i]; j++) putchar(s[::st[i] + j]);
pre += len[i] + 1;
}
puts("");
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int fa[1000005][21];
int st[1000005], en[1000005], Last[1000005];
char str[10 * 1000005];
int get(int L, int R, int len) {
int res = L;
while (L <= R) {
int mid = (L + R) >> 1;
if (en[mid] <= len) {
res = mid;
L = mid + 1;
} else
R = mid - 1;
}
return res;
}
void solve(int v, int step, int &res) {
int i;
res = v;
for (i = 21 - 1; i >= 0; i--)
if (step >= (1 << i)) {
if (fa[v][i] != -1) {
res = fa[v][i];
v = fa[v][i];
step -= 1 << i;
}
}
}
int main() {
int n, R, C, i, j, k;
while (scanf("%d %d %d", &n, &R, &C) != EOF) {
gets(str);
gets(str);
int len = strlen(str);
k = 1;
for (i = 0; i < len; i++) {
st[k] = i;
j = i;
while (j < len && str[j] != ' ') j++;
en[k++] = j - 1;
i = j;
}
memset(fa, -1, sizeof(fa));
for (i = 1; i <= n; i++) {
if (en[i] - st[i] + 1 <= C) {
fa[i][0] = get(i, n, st[i] + C - 1) + 1;
} else
fa[i][0] = -1;
}
for (i = n; i >= 1; i--) {
if (fa[i][0] == -1) continue;
for (j = 1; j < 21; j++) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
if (fa[i][j] == -1) break;
}
}
int ans = 0, x = 0;
for (i = 1; i <= n; i++) {
if (fa[i][0] == -1) continue;
solve(i, R, Last[i]);
if (Last[i] - i > ans) {
ans = Last[i] - i;
x = i;
}
}
for (i = 0; i < R; i++) {
if (x != -1 && fa[x][0] != -1) {
for (j = st[x]; j <= en[fa[x][0] - 1]; j++) printf("%c", str[j]);
}
puts("");
x = fa[x][0];
if (x == -1) break;
}
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / gcd(a, b));
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int ddx[] = {0, 0, 1, 1, 1, -1, -1, -1}, ddy[] = {1, -1, 1, 0, -1, 1, 0, -1};
string s[1000000];
int n, r, c, to[1000001][20];
pair<int, int> p[1000000];
int res(int l) {
int now = l;
for (int(i) = (19); (i) >= (0); (i) -= (1)) {
if (r & (1 << i)) {
now = to[now][i];
}
}
return now - l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r >> c;
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) cin >> s[i];
p[0].first = 0, p[0].second = s[0].length() - 1;
for (int(i) = (1); (i) <= (n - 1); (i) += (1)) {
p[i].first = p[i - 1].second + 2;
p[i].second = p[i].first + s[i].length() - 1;
}
to[n][0] = n;
int rr = 0;
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
if (s[i].length() > c) {
to[i][0] = i;
rr = i + 1;
} else {
while (rr < n && p[rr].second - p[i].first + 1 <= c) rr++;
to[i][0] = rr;
}
}
for (int(j) = (1); (j) <= (19); (j) += (1))
for (int(i) = (0); (i) <= (n); (i) += (1))
to[i][j] = to[to[i][j - 1]][j - 1];
int ans = -1, what = -1;
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
int t = res(i);
if (t > ans) {
ans = t;
what = i;
}
}
for (int(i) = (0); (i) <= (r - 1); (i) += (1)) {
for (int(j) = (what); (j) <= (to[what][0] - 1); (j) += (1)) {
if (j != what) cout << ' ';
cout << s[j];
}
cout << '\n';
what = to[what][0];
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1000005;
int n, r, c;
string words[NMAX];
int s_part[NMAX];
inline int space(int left, int right) {
return s_part[right] - s_part[left - 1] + right - left;
}
int dp[20][NMAX];
inline void precalc_dp() {
for (int i = 1; i <= n; ++i) {
int left = i;
int right = n;
int best = i - 1;
int middle;
while (left <= right) {
middle = (left + right) >> 1;
if (space(i, middle) <= c) {
best = middle;
left = middle + 1;
} else
right = middle - 1;
}
dp[0][i] = best;
}
int j;
for (int i = 1; (1 << i) <= n; ++i)
for (j = 1; j <= n; ++j)
if (dp[i - 1][j] + 1 > n)
dp[i][j] = n;
else
dp[i][j] = dp[i - 1][dp[i - 1][j] + 1];
}
int get_best(int pos) {
int i = 0;
for (; (1 << i) <= r; ++i)
;
--i;
int where = pos - 1;
for (; i >= 0 && where < n; --i)
if (r & (1 << i)) where = dp[i][where + 1];
return where;
}
inline void print(int left, int right) {
cout << words[left];
int current = words[left].size();
for (int i = left + 1; i <= right; ++i) {
if (current + 1 + words[i].size() <= c) {
cout << ' ' << words[i];
current += (1 + words[i].size());
} else {
cout << '\n' << words[i];
current = words[i].size();
}
}
cout << '\n';
}
int main() {
ios_base ::sync_with_stdio(false);
cin >> n >> r >> c;
if (r > n) r = n;
for (int i = 1; i <= n; ++i) cin >> words[i];
for (int i = 1; i <= n; ++i) s_part[i] = s_part[i - 1] + words[i].size();
precalc_dp();
int l_best = 0;
int where = 0;
int aux;
for (int i = 1; i <= n; ++i) {
aux = get_best(i);
if (aux - i + 1 > l_best) l_best = aux - i + 1, where = i;
}
if (l_best == 0) return 0;
print(where, where + l_best - 1);
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, r, c, a[1000011], sum[1000011], nxt[1000011][21];
string s[5000011];
int main() {
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; ++i) {
cin >> s[i];
a[i] = s[i].length();
sum[i] = sum[i - 1] + a[i];
}
int cur = 1;
for (int i = 0; i <= 20; ++i) nxt[n + 1][i] = n + 1;
for (int i = 1; i <= n; ++i) {
while (cur <= n && sum[cur] - sum[i - 1] + cur - i <= c) ++cur;
nxt[i][0] = cur;
}
for (int i = 1; i <= 20; ++i)
for (int j = 1; j <= n; ++j) nxt[j][i] = nxt[nxt[j][i - 1]][i - 1];
int id = -1, ans = 0;
for (int i = 1; i <= n; ++i) {
int x = i;
for (int j = 20; ~j; --j) {
if (r >> j & 1) x = nxt[x][j];
}
if (x - i > ans) ans = x - i, id = i;
}
int cnt = -1;
for (int i = 1; i <= ans; ++i) {
if (i > 1)
if (cnt + 1 + a[id + i - 1] > c)
putchar(10), cnt = -1;
else
putchar(32);
cnt += 1 + a[id + i - 1];
cout << s[id + i - 1];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e6 + 6;
int n, r, c, t = 1, fr[mxn], nxt[mxn], ans[mxn];
char s[6 * mxn];
inline void dfs(int x) {
if (!x) return;
dfs(x >> 1);
for (int i = 1; i <= n; ++i) {
ans[i] = ans[ans[i]];
if (x & 1) ans[i] = nxt[ans[i]];
}
}
int main() {
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; ++i) {
scanf("%s", s + fr[i]);
fr[i + 1] = fr[i] + strlen(s + fr[i]);
s[fr[i + 1]++] = ' ';
}
for (int i = n + 1, j = n + 1; i; nxt[ans[i] = i] = j, --i)
for (; fr[j] - fr[i] > c + 1; --j)
;
dfs(r);
for (int i = 2; i <= n; ++i)
if (ans[i] - i > ans[t] - t) t = i;
for (int i = 1; i <= r; ++i, t = nxt[t], putchar('\n'))
for (int j = fr[t]; j + 1 < fr[nxt[t]]; j++) putchar(s[j]);
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 5;
int n, r, c, o, ans = -1;
string word[N];
int sum[N], f[N], d[N], p[N];
vector<int> e[N];
void dfs(int u, int k) {
if (k - u > ans) {
ans = k - u;
o = u;
}
for (vector<int>::iterator j = e[u].begin(); j != e[u].end(); j++) {
int v = *j;
p[u] = v;
dfs(v, d[v] - d[k] <= r ? k : p[k]);
}
}
int main() {
cin >> n >> r >> c;
for (int i = 1; i <= n; i++) {
cin >> word[i];
sum[i] = sum[i - 1] + word[i].size() + 1;
}
c++;
for (int i = 1, j = 1; i <= n + 1; i++) {
for (; j < n + 1 && sum[j] - sum[i - 1] <= c; j++)
;
f[i] = j;
if (j > i) e[j].push_back(i);
}
for (int i = n + 1; i >= 1; i--) d[i] = d[f[i]] + 1;
for (int i = 1; i <= n + 1; i++)
if (f[i] == i) dfs(i, i);
if (ans == -1) return 0;
for (int i = 0; i < r; i++) {
for (int j = o; j < f[o]; j++) cout << word[j] << " \n"[j + 1 == f[o]];
o = f[o];
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000006;
int l[N], f[N], num[N];
string s[N];
int main() {
int i, n, r, c;
ios_base::sync_with_stdio(false);
cin >> n >> r >> c;
for (i = 0; i < n; ++i) {
cin >> s[i];
l[i] = s[i].size();
}
l[n] = N;
int a = 0, b = 0;
int tmp = l[0];
while (a <= n) {
if (tmp <= c) {
b++;
tmp += l[b] + 1;
} else
f[a] = b, tmp -= l[a] + 1, a++;
}
for (i = 0; i <= n; ++i) num[i] = i;
int rr = r;
while (r > 0) {
if (r & 1)
for (i = 0; i <= n; ++i) num[i] = f[num[i]];
r >>= 1;
for (i = 0; i <= n; ++i) f[i] = f[f[i]];
}
int now = 0;
for (i = 0; i < n; ++i)
if (num[i] - i > num[now] - now) now = i;
for (i = 0; i < rr; ++i) {
int tmp = -1;
while (tmp + l[now] + 1 <= c) {
if (tmp >= 0) cout << " ";
cout << s[now];
tmp += l[now] + 1;
now++;
}
cout << "\n";
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000010;
int n, r, c;
char t[MaxN * 5];
string s[MaxN];
int v[MaxN];
int to[MaxN][20];
int main() {
cin >> n >> r >> c;
for (int i = 1; i <= n; ++i) {
scanf("%s", t);
s[i] = t;
v[i] = s[i].size();
}
for (int i = 1; i <= n; ++i) v[i] += v[i - 1];
for (int i = n, j = n; i >= 1; --i) {
while (v[j] - v[i - 1] + j - i > c) --j;
to[i][0] = j + 1;
}
to[n + 1][0] = n + 1;
for (int k = 1; k < 20; ++k)
for (int i = 1; i <= n + 1; ++i) to[i][k] = to[to[i][k - 1]][k - 1];
pair<int, int> p(0, 0);
for (int i = 1; i <= n; ++i) {
int x = i;
int t = r;
for (int k = 19; k >= 0; --k)
if (t >= 1 << k) {
t -= 1 << k;
x = to[x][k];
}
p = max(p, pair<int, int>(x - i, i));
}
int x = p.second;
for (int i = 1; i <= r; ++i) {
for (int j = x; j < to[x][0]; ++j) {
if (j > x) putchar(' ');
printf("%s", s[j].c_str());
}
puts("");
x = to[x][0];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1001000;
int pfx[NMAX];
int f[NMAX][20];
string s[NMAX];
int n, r, c;
void buildf() {
int j = 1;
for (int i = 1; i <= n; ++i) {
while (j <= n && pfx[j] - pfx[i - 1] - 1 <= c) {
++j;
}
f[i][0] = j;
}
f[n + 1][0] = n + 1;
for (int l = 1; l < 20; ++l) {
for (int i = 1; i <= n + 1; ++i) {
f[i][l] = f[f[i][l - 1]][l - 1];
}
}
}
void swim(int& x, int h) {
for (int i = 0; i < 20; ++i) {
if (h & 1) x = f[x][i];
h >>= 1;
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> r >> c;
for (int i = 1; i <= n; ++i) {
cin >> s[i];
}
pfx[0] = 0;
for (int i = 1; i <= n; ++i) {
pfx[i] = pfx[i - 1] + s[i].size() + 1;
}
buildf();
pair<long long, long long> best(0, 0);
for (int i = 1; i <= n; ++i) {
int j = i;
swim(j, r);
best = max(best, pair<long long, long long>(j - i, i));
}
int p = best.second;
int sz = 0;
for (int i = 0; i < r && sz < best.first; + i, p = f[p][0]) {
for (int j = p; j < f[p][0] - 1; ++j) {
cout << s[j] << " ";
++sz;
}
cout << s[f[p][0] - 1] << "\n";
++sz;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f ^= 1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return f ? x : -x;
}
int n, r, c;
string text;
string s;
int st[1000005];
char tmp[5000005];
int table[1000005][20];
int main() {
n = read(), r = read(), c = read();
for (int i = 0; i < (int)(n); ++i) {
scanf("%s", tmp);
s = tmp;
st[i] = text.size();
text += s + ' ';
}
st[n] = text.size();
for (int i = 0; i < (int)(n); ++i) {
int lb = 0, rb = n - i;
while (lb < rb) {
int md = (lb + rb + 1) >> 1;
if (st[i + md] - st[i] - 1 <= c)
lb = md;
else
rb = md - 1;
}
table[i][0] = lb;
}
for (int j = 1; j < 20; ++j) {
for (int i = 0; i < (int)(n); ++i) {
table[i][j] = table[i][j - 1] + table[i + table[i][j - 1]][j - 1];
}
}
int ans = 0, ansn = -1;
for (int i = 0; i < (int)(n); ++i) {
int cnt = 0;
int x = i;
for (int j = 0; j < (int)(20); ++j)
if (r & 1 << j) {
cnt += table[x][j];
x += table[x][j];
}
if (cnt > ans) ans = cnt, ansn = i;
}
int x = ansn;
for (int i = 0; i < (int)(r); ++i) {
if (table[x][0] != 0)
printf("%s\n",
text.substr(st[x], st[x + table[x][0]] - st[x] - 1).c_str());
x += table[x][0];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int n, r, c, a[N], nxt[N][21];
string s[N];
int get_idx(int cur) {
int res = cur;
for (int i = 20; i >= 0; i--) {
if (((r >> i) & 1) == 1) {
res = nxt[res][i];
}
}
return res;
}
void solve() {
int p = 0;
int cur = 0;
int cnt = 0;
nxt[n + 1][0] = n + 1;
for (int i = 1; i <= n; i++) {
while (p <= n && cur + cnt - 1 <= c) {
cur += a[++p];
cnt++;
}
nxt[i][0] = p;
cur -= a[i];
cnt--;
}
for (int j = 1; j <= 20; j++) {
for (int i = 1; i <= n + 1; i++) {
nxt[i][j] = nxt[nxt[i][j - 1]][j - 1];
}
}
int mx = 0;
p = -1;
for (int i = 1; i <= n; i++) {
int j = get_idx(i);
if (i == j) {
continue;
}
if (j - i > mx) {
mx = j - i;
p = i;
}
}
cur = 1;
for (int i = p; i <= p + mx - 1;) {
if (cur > r) {
break;
}
int cur_length = ((int)(s[i]).size());
cout << s[i++];
while (i <= p + mx - 1) {
if ((cur_length + 1 + ((int)(s[i]).size())) > c) {
break;
}
cur_length += 1 + ((int)(s[i]).size());
cout << " " << s[i++];
}
cout << "\n";
cur++;
}
}
int main() {
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; i++) {
cin >> s[i];
a[i] = ((int)(s[i]).size());
}
solve();
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1000000;
const int max_lgr = 20;
const int max_char = 5000000 + max_n;
int n, r, c;
char *str[max_n];
int pos[max_n + 1], nxt[max_lgr + 1][max_n + 1];
char buf[max_char + 1] = {0};
int main() {
scanf("%d %d %d", &n, &r, &c);
char *ptr = buf;
for (int i = 0; i < n; i++) {
str[i] = ptr;
scanf("%s", ptr);
while (*ptr) ptr++;
ptr++;
}
pos[n] = ptr - buf;
for (int i = 0; i < n; i++) pos[i] = str[i] - buf;
nxt[0][n] = n;
for (int i = 0; i < n; i++)
nxt[0][i] = upper_bound(pos, pos + n + 1, pos[i] + c + 1) - pos - 1;
for (int i = 0; i < max_lgr; i++)
for (int j = 0; j <= n; j++) nxt[i + 1][j] = nxt[i][nxt[i][j]];
int ans = -1, lb;
for (int st = 0; st < n; st++) {
int ed = st;
for (int i = 0; i < max_lgr; i++)
if ((1 << i) & r) ed = nxt[i][ed];
if (ans < ed - st) {
ans = ed - st;
lb = st;
}
}
assert(ans >= 0);
for (int i = 0; i < r; i++) {
for (int j = lb; j < nxt[0][lb]; j++) printf(" %s" + (j == lb), str[j]);
printf("\n");
lb = nxt[0][lb];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6000000 + 9;
const int M = 1000000 + 9;
char pat[N];
int n, r, c, sta[M], len[M], trans[M][18], position, vout;
inline int read() {
char c = getchar();
int ret = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
ret = ret * 10 + c - '0';
c = getchar();
}
return ret * f;
}
int main() {
n = read();
r = read();
c = read();
gets(pat + 1);
for (int i = 1, tmp = strlen(pat + 1); i <= tmp; i++)
if (pat[i] == ' ') {
pat[i] = 0;
}
for (int i = 1, w = 0; i <= n; i++) {
sta[i] = ++w;
len[i] = strlen(pat + w);
w += len[i];
}
for (int i = 1, tail = 1, tmp = len[1]; i <= n; i++) {
if (len[i] > c) {
tail = (i + 1) % (n + 1);
tmp = len[tail];
} else {
while (tail < n && tmp + len[tail + 1] + 1 <= c) {
tmp += len[++tail] + 1;
}
trans[i][0] = tail + 1;
tmp -= len[i] + (tail > i);
if (!tmp) {
tail = (i + 1) % (n + 1);
tmp = len[tail];
}
}
}
trans[n][0] = n;
for (int t = 1; t <= 17; t++) {
for (int i = 1; i <= n; i++) {
trans[i][t] = max(trans[i][t - 1], trans[trans[i][t - 1]][t - 1]);
}
}
for (int i = 1, tmp = 0, p = i; i <= n; tmp = 0, p = ++i) {
for (int j = 17, w = 1 << 17; ~j; j--, w >>= 1)
if (tmp + w <= r) {
tmp += w;
p = max(p, trans[p][j]);
if (p == n + 1) break;
}
if (p - i > vout) {
vout = p - i;
position = i;
}
}
if (vout)
for (int i = 1, beg = position, end; i <= r && beg <= n; i++) {
end = trans[beg][0] - (beg != n || len[trans[beg][0]] > c);
if (end < beg) break;
for (int j = beg; j <= end; j++) {
printf("%s%c", pat + sta[j], j == end ? '\n' : ' ');
}
beg = end + 1;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000033;
char s[5000033];
int e[maxn], p[maxn], f[maxn], n, r, c, L = 1;
int main() {
scanf("%d%d%d\n", &n, &r, &c);
for (int i = 1; i <= n; e[i] = L - 1, i++)
while (isalpha(s[L] = getchar())) ++L;
for (int i = 1, j = 0; i <= n; f[i] = p[i] = j, i++)
for (; e[i] - e[j] + i - j - 1 > c; j++)
;
for (int i = r - 1; i; i /= 2)
for (int j = n; j; --j) i & 1 ? p[j] = f[p[j]] : 0, f[j] = f[f[j]];
int t, v = 0;
for (int i = 1; i <= n; i++)
if (i - p[i] > v) v = i - p[i], t = p[i];
for (int m; r; r--, t = m - 1, puts("")) {
for (m = t; m <= n && e[m] - e[t] + m - t - 1 <= c; m++)
;
for (int i = t + 1; i < m; i++, i < m ? putchar(' ') : 0)
for (int j = e[i - 1] + 1; j <= e[i]; ++j) putchar(s[j]);
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int f[1000001][21];
int g[1000001];
int len[1000001];
int sl[1000001];
int st[1000001];
string a[1000001];
char s1[1000001];
int n, r, c;
char ch;
void print(int k) {
for (int i = 0; i < len[k]; i++) printf("%c", a[k][i]);
return;
}
int main() {
scanf("%d%d%d", &n, &r, &c);
scanf("%c", &ch);
int z = 1;
while (z <= n) {
ch = getchar();
if (ch == ' ')
z++;
else if (ch == '\n')
break;
else
a[z] += ch;
}
for (int i = 1; i <= n; i++) len[i] = a[i].length();
int l = 0;
int l1 = 0;
int ans = 1;
for (int i = 1; i <= n; i++) {
l1 += len[i] + 1;
while (l1 - 1 > c) {
l++;
l1 -= len[l] + 1;
}
f[i][0] = l;
}
for (int i = 1; i <= n; i++) sl[i] = sl[i - 1] + (f[i][0] != i);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
for (int i = 1; i <= n; i++) {
g[i] = i;
for (int j = 19; j >= 0; j--)
if ((1 << j) & r) g[i] = f[g[i]][j];
}
for (int i = 1; i <= n; i++)
if (sl[i] - sl[g[i] - 1] > sl[ans] - sl[g[ans] - 1]) ans = i;
z = 0;
int temp = ans;
for (int i = 1; i <= r; i++) {
st[++z] = temp;
if (temp == g[ans]) st[z]++;
temp = f[temp][0];
}
for (int i = g[ans] + 1; i <= ans; i++) {
print(i);
if (i == st[z])
printf("\n"), z--;
else
printf(" ");
while (z > 0 && st[z] <= i) z--;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
int n, r, c, l[maxn], sum[maxn];
string word[maxn];
int last[maxn][25], ans[maxn];
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> r >> c;
cin.get();
sum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> word[i];
l[i] = word[i].size();
sum[i] = sum[i - 1] + l[i];
}
cin.get();
int p = 0;
memset(last, 0, sizeof(last));
for (int i = 1; i <= n; i++) {
if (l[i] > c) {
p = i;
continue;
}
while (p + 1 <= n && sum[p + 1] - sum[i - 1] + p + 1 - i <= c) p++;
last[i][0] = p;
}
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= 20; j++)
if (last[i][j - 1] != 0) {
if (last[i][j - 1] == n)
last[i][j] = n;
else if (last[last[i][j - 1] + 1][j - 1] != 0)
last[i][j] = last[last[i][j - 1] + 1][j - 1];
else
last[i][j] = last[i][j - 1];
}
}
for (int i = 1; i <= n; i++) {
int now = i;
for (int j = 20; j >= 0; j--)
if (((r >> j) & 1) && now != n + 1 && last[now][j] != 0)
now = last[now][j] + 1;
now--;
ans[i] = now;
}
int ax = 0;
ans[0] = -10000;
for (int i = 1; i <= n; i++)
if (ans[i] - i + 1 > ans[ax] - ax + 1) ax = i;
int now = ax, cnt = 1;
while (cnt <= r) {
if (last[now][0] != 0 && now != n + 1) {
for (int i = now; i < last[now][0]; i++) cout << word[i] << " ";
cout << word[last[now][0]] << endl;
now = last[now][0] + 1;
} else
cout << endl;
cnt++;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int fit[1000002][19];
vector<string> words;
int main() {
long long n, r, c;
cin >> n >> r >> c;
vector<string> words(n);
for (int i = 0; i < n; i++) cin >> words[i];
int lp = 0;
int rp = 0;
int numchars = -1;
while (lp < n) {
while (rp < n && numchars + words[rp].size() + 1 <= c) {
numchars += words[rp].size() + 1;
rp++;
}
fit[lp][0] = rp;
numchars -= words[lp].size() + 1;
lp++;
if (rp < lp) {
numchars = -1;
rp = lp;
}
}
int logr = 0;
while ((1 << logr) <= r) logr++;
logr--;
for (int j = 0; j <= logr; j++) fit[n][j] = n;
for (int j = 1; j <= logr; j++) {
for (int i = 0; i < n; i++) {
fit[i][j] = fit[fit[i][j - 1]][j - 1];
}
}
int bestidx = -1;
int bestcnt = -1;
for (int i = 0; i < n; i++) {
int curridx = i;
int tmpr = r;
for (int j = logr; j >= 0; j--) {
if ((1 << j) <= tmpr) {
curridx = fit[curridx][j];
tmpr -= (1 << j);
if (curridx == n) break;
}
}
if (curridx - i > bestcnt) {
bestcnt = curridx - i;
bestidx = i;
}
}
numchars = -1;
for (int i = bestidx; i < bestidx + bestcnt; i++) {
if (numchars + words[i].size() + 1 > c) {
cout << "\n";
numchars = -1;
}
if (numchars != -1) cout << " ";
cout << words[i];
numchars += words[i].size() + 1;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
string A[1000005];
char ST[5000005];
int F[1000005], S[1000005];
int Go[22][1000005];
int main() {
int n, r, c, i, j, k, l;
scanf("%d%d%d", &n, &r, &c);
for (i = 1; i <= n; i++) {
scanf("%s", ST);
A[i] = ST;
S[i] = S[i - 1] + A[i].size();
}
F[n + 1] = n + 1;
j = n + 1;
for (i = n; i >= 1; i--) {
while (S[j - 1] - S[i - 1] + (j - i - 1) > c) j--;
F[i] = j;
}
for (i = 1; i <= n + 1; i++) Go[0][i] = F[i];
for (j = 1; j < 21; j++)
for (i = 1; i <= n + 1; i++) Go[j][i] = Go[j - 1][Go[j - 1][i]];
int ans = 0, ansi = 0, anse = 0;
for (i = 1; i <= n; i++) {
k = i;
for (j = 0; j < 21; j++)
if ((1 << j) & r) k = Go[j][k];
if (ans < k - i) {
ans = k - i;
ansi = i;
anse = k;
}
}
i = ansi;
while (i != anse) {
for (j = i; j < F[i] - 1; j++) cout << A[j] << ' ';
cout << A[j] << endl;
i = F[i];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int M = 5000010;
const int Log = 20;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const long long linf = 2e18;
const int mod = 1000000007;
const double eps = 1e-7;
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T>
void chmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
void Tmin(T &a, T &b, T &c) {
return min(a, min(b, c));
}
template <class T>
void Tmax(T &a, T &b, T &c) {
return max(a, max(b, c));
}
void add(int &a, int b) { a = a + b < mod ? a + b : a + b - mod; }
void sub(int &a, int b) { a = (a - b + mod) % mod; }
void mul(int &a, int b) { a = (long long)a * b % mod; }
int addv(int a, int b) { return (a += b) >= mod ? a -= mod : a; }
int subv(int a, int b) { return (a -= b) < 0 ? a += mod : a; }
int mulv(int a, int b) { return (long long)a * b % mod; }
int read() {
int f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int pw(int a, int b) {
int s = 1;
for (; b; b >>= 1, a = (long long)a * a % mod)
if (b & 1) s = (long long)s * a % mod;
return s;
}
int n, x, y;
char buf[M];
string s[N];
int sum[N], last[N], ans[N];
int multi[N][25];
void print(int x, int y) {
if (x == y) return;
for (int i = (x); i <= (y - 1); i++) {
cout << s[i];
if (i == y - 1)
cout << endl;
else
putchar(' ');
}
}
signed main() {
scanf("%d%d%d", &n, &x, &y);
for (int i = (0); i <= (n - 1); i++) cin >> s[i];
for (int i = (0); i <= (n - 1); i++)
sum[i + 1] = sum[i] + ((int)s[i].size()) + 1;
int j = n;
last[n] = n;
for (int i = (n - 1); i >= (0); i--) {
while (sum[j] - sum[i] > y + 1) j--;
last[i] = j;
}
for (int i = (0); i <= (n); i++) multi[i][0] = last[i];
for (int i = (1); i <= (Log); i++)
for (int j = (0); j <= (n); j++)
multi[j][i] = multi[multi[j][i - 1]][i - 1];
for (int i = (0); i <= (n); i++) {
int tmp = i;
for (int j = (0); j <= (Log); j++)
if (x & (1 << j)) tmp = multi[tmp][j];
ans[i] = tmp;
}
int from = 0, to = ans[0];
for (int i = (0); i <= (n); i++)
if (ans[i] - i > to - from) {
from = i;
to = ans[i];
}
for (int i = (0); i <= (x - 1); i++) {
print(from, last[from]);
from = last[from];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int a[1000005], nex[1000005], ans[1000005];
char s[6000005];
int n, r, c, t = 1;
void ksm(int x) {
if (!x) return;
ksm(x >> 1);
for (int i = 1; i <= n; i++) {
ans[i] = ans[ans[i]];
if (x & 1) ans[i] = nex[ans[i]];
}
}
int main() {
scanf("%d%d%d", &n, &r, &c);
for (int i = 1; i <= n; i++)
scanf("%s", s + a[i]), a[i + 1] = a[i] + strlen(s + a[i]),
s[a[i + 1]++] = ' ';
for (int i = n + 1, j = n + 1; i; i--) {
while (a[j] - a[i] > c + 1) j--;
nex[ans[i] = i] = j;
}
ksm(r);
for (int i = 2; i <= n; i++)
if (ans[i] - i > ans[t] - t) t = i;
for (int i = 1; i <= r; i++, t = nex[t], puts(""))
for (int j = a[t]; j + 1 < a[nex[t]]; j++) putchar(s[j]);
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const int MAXN = 1e6 + 20;
string s[MAXN];
int _next_[MAXN];
vector<int> edge[MAXN];
vector<int> sta;
int n, r, c;
pair<int, pair<int, int> > ans(0, pair<int, int>(0, 0));
inline void dfs(int u) {
sta.push_back(u);
int now = (int((sta).size())) - 1;
if (now < r) now = r;
int pre = sta[now - r];
ans = max(ans, make_pair(pre - u, pair<int, int>(u, pre)));
for (auto v : edge[u]) dfs(v);
sta.pop_back();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cin >> n >> r >> c;
for (register int i = (1); i <= (n); ++i) {
cin >> s[i];
}
int rt = 1, tot = 0;
for (register int i = (1); i <= (n); ++i) {
if (tot == (int((s[i - 1]).size()))) {
tot = (int((s[i]).size())), rt = i;
} else if (tot == 0) {
tot = (int((s[i]).size())), rt = i;
} else
tot -= (int((s[i - 1]).size())) + 1;
while (rt < n && tot + (int((s[rt + 1]).size())) + 1 <= c) {
tot += (int((s[rt + 1]).size())) + 1;
++rt;
}
if (tot <= c) {
_next_[i] = rt + 1;
edge[_next_[i]].push_back(i);
}
}
dfs(n + 1);
for (register int i = (1); i <= (n); ++i) {
if ((int((s[i]).size())) > c) dfs(i);
}
int now = ans.second.first;
while (now != ans.second.second) {
for (register int i = (now); i <= (_next_[now] - 1); ++i) {
cout << s[i] << (i == _next_[now] - 1 ? '\n' : ' ');
}
now = _next_[now];
if (!now) break;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
string i_s(int x) {
if (x == 0) return "0";
string ret = "";
while (x) {
ret = ret + (char)(x % 10 + '0');
x /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
string add(string a, string b) {
if (a == "") a = "0";
if (b == "") b = "0";
if (a.length() < b.length()) swap(a, b);
while (b.length() < a.length()) {
b = '0' + b;
}
for (int i = 0; i < a.length(); i++) {
a[i] = a[i] + (b[i] - '0');
}
bool big = false;
for (int i = a.length() - 1; i >= 0; i--) {
if (big) {
a[i]++;
}
big = false;
if (a[i] > '9') {
a[i] = a[i] - 10;
big = true;
}
}
if (big) a = '1' + a;
return a;
}
string mul(string a, string b) {
vector<int> va, vb;
if (a == "0" || b == "0") return "0";
string ans;
for (int i = 0; i < a.length(); i++) {
va.push_back(a[i] - '0');
}
for (int i = 0; i < b.length(); i++) {
vb.push_back(b[i] - '0');
}
reverse(va.begin(), va.end());
reverse(vb.begin(), vb.end());
vector<int> res;
res.clear();
res.resize(1005);
for (int i = 0; i < a.length(); i++) {
for (int j = 0; j < b.length(); j++) {
res[i + j] += (va[i] * vb[j]);
}
}
for (int i = 0; i < 1005; i++) {
if (res[i] > 9) {
res[i + 1] += (res[i] / 10);
res[i] %= 10;
}
}
for (int i = 0; i < 1005; i++) {
ans += (res[i] + '0');
}
reverse(ans.begin(), ans.end());
int k = 0;
while (ans[k] == '0') {
k++;
}
ans = ans.substr(k);
return ans;
}
int n, c, r, ans;
int l[1000005], res[1000005], sum[1000005];
int st[1000005][21];
string s[1000005];
int main() {
cin >> n >> r >> c;
for (int i = 0; i < n; i++) cin >> s[i], l[i] = s[i].size();
for (int i = 0; i < n; i++) sum[i] = l[i] + (i ? sum[i - 1] + 1 : 0);
for (int i = 0; i < n; i++) {
int &pos = st[i][0];
pos = upper_bound(sum, sum + n, (i ? (sum[i - 1] + 1) : 0) + c) - sum;
pos = max(pos, i);
}
for (int j = 1; j < 21; j++)
for (int i = 0; i < n; i++) {
if (st[i][j - 1] == n)
st[i][j] = n;
else
st[i][j] = st[st[i][j - 1]][j - 1];
}
st[n][0] = n;
for (int i = 0; i < n; i++) {
int j = i;
for (int k = 20; k >= 0; --k)
if (r >> k & 1) {
j = st[j][k];
if (j == n) break;
}
ans = max(ans, j - i);
res[i] = j;
}
for (int i = 0; i < n; i++)
if (res[i] - i == ans) {
int len = 0;
for (int j = i; j < res[i]; j++) {
if (j == i) {
cout << s[j];
len += l[j];
continue;
}
if (len + l[j] + 1 > c) {
puts("");
cout << s[j];
len = l[j];
} else {
cout << " " << s[j];
len += l[j] + 1;
}
}
return 0;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long bst, bp, qpos;
long n, r, c, sz[2000000], rr, span;
long ans[1100000][23];
string st[1100000];
long nlfl, ql;
double explen;
void do_nline(long i) {
nlfl = 1;
cout << endl;
ql = 0;
explen = sz[i];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> r >> c;
for (int i = 1; i <= n; i++) {
cin >> st[i];
sz[i] = st[i].size();
}
rr = n;
for (int i = n; i; --i) {
span += sz[i] + 1;
if (rr == i) span = sz[i];
while (span > c) {
if (rr > i)
span -= (sz[rr] + 1);
else
span -= sz[rr];
--rr;
}
ans[i][0] = rr;
}
for (int pw = 0; pw <= 22; pw++) ans[n + 1][pw] = n;
for (long pw = 1; pw <= 22; pw++)
for (long i = n; i >= 1; --i)
ans[i][pw] = max(i - 1, ans[ans[i][pw - 1] + 1][pw - 1]);
bst = -1000;
bp = 0;
for (int i = 1; i <= n; i++) {
qpos = i - 1;
for (int pw = 20; pw >= 0; --pw)
if (r & (1 << pw)) qpos = ans[qpos + 1][pw];
span = qpos - i + 1;
if (span > bst) {
bst = span;
bp = i;
}
}
ql = 0;
nlfl = 1;
for (int i = bp; i < bp + bst; i++) {
explen = ql + sz[i];
if (i > bp) explen++;
if (explen > c) {
do_nline(i);
}
if (nlfl == 0) cout << " ";
cout << st[i];
nlfl = 0;
ql = explen;
}
cout << endl;
cin.get();
cin.get();
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
char buf[6000010];
int N, R, C;
string S[1000010];
int A[1000010];
int ASum[1000010];
int to[1000010];
int crt[1000010], nxt[1000010];
void solve(int e) {
int i;
if (e == 0) {
for (i = 0; i <= N; ++i) {
crt[i] = i;
}
return;
}
solve(e / 2);
for (i = 0; i <= N; ++i) {
nxt[i] = crt[crt[i]];
}
if (e % 2 != 0) {
for (i = 0; i <= N; ++i) {
crt[i] = to[nxt[i]];
}
} else {
for (i = 0; i <= N; ++i) {
crt[i] = nxt[i];
}
}
}
int main() {
int i, j, r;
for (; ~scanf("%d%d%d", &N, &R, &C);) {
for (i = 0; i < N; ++i) {
scanf("%s", buf);
S[i] = buf;
}
for (i = 0; i < N; ++i) {
A[i] = S[i].size() + 1;
}
for (i = 0; i < N; ++i) {
ASum[i + 1] = ASum[i] + A[i];
}
for (j = 0, i = 0; i <= N; ++i) {
for (; j <= N && ASum[j] - ASum[i] <= C + 1; ++j)
;
--j;
to[i] = j;
}
solve(R);
int opt = -1;
int im = -1;
for (i = 0; i <= N; ++i) {
if (opt < crt[i] - i) {
opt = crt[i] - i;
im = i;
}
}
for (r = 0; r < R; ++r) {
if (im == to[im]) {
break;
}
for (i = im; i < to[im]; ++i) {
if (i > im) printf(" ");
printf("%s", S[i].c_str());
}
puts("");
im = to[im];
}
cerr << "====" << endl;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int LOG = 21;
int n, r, c;
string lst[N];
int nx[LOG][N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> r >> c;
for (int i = 0; i < n; ++i) cin >> lst[i];
int sum = -1;
int p2 = 0;
for (int i = 0; i < n; ++i) {
while (p2 < i) {
sum += lst[p2].size() + 1;
p2++;
}
if (i > 0) sum -= lst[i - 1].size() + 1;
while (p2 < n && sum + lst[p2].size() + 1 <= c) {
sum += lst[p2].size() + 1;
p2++;
}
nx[0][i] = p2;
}
nx[0][n] = n;
for (int i = 1; i < LOG; ++i) {
for (int j = 0; j < n; ++j) {
if (nx[i - 1][j] == n)
nx[i][j] = n;
else
nx[i][j] = nx[i - 1][nx[i - 1][j]];
}
nx[i][n] = n;
}
int start = -1;
int best = -1;
for (int i = 0; i < n; ++i) {
int tmp = r;
int cur = i;
for (int j = LOG - 1; j >= 0; --j) {
if (tmp & (1 << j)) {
cur = nx[j][cur];
}
}
if (best < cur - i) {
best = cur - i;
start = i;
}
}
while (r--) {
for (int i = start; i < nx[0][start]; ++i) {
if (i != start) cout << " ";
cout << lst[i];
}
start = nx[0][start];
cout << endl;
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n;
int N, M;
string words[1000011];
int lens[1000011];
int sumLens[1000011];
int maxNext[1000011][21];
int MAIN() {
while (cin >> n >> N >> M) {
for (int i = 1; i <= n; i++) {
cin >> words[i];
lens[i] = words[i].length();
}
memset(sumLens, 0, sizeof(sumLens));
for (int i = 1; i <= n; i++) {
sumLens[i] = lens[i] + sumLens[i - 1];
}
int pos = 1;
for (int i = 0; i <= 20; i++) maxNext[n + 1][i] = n + 1;
for (int i = 1; i <= n; i++) {
while (pos <= n && sumLens[pos] - sumLens[i - 1] + (pos - i) <= M) pos++;
maxNext[i][0] = pos;
}
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= n; j++)
maxNext[j][i] = maxNext[maxNext[j][i - 1]][i - 1];
int maxAns = -1, startWith;
for (int i = 1; i <= n; i++) {
int p = i;
for (int j = 0; j <= 20; j++)
if ((N & (1 << j)) > 0) {
p = maxNext[p][j];
}
if (p - i > maxAns) {
maxAns = p - i;
startWith = i;
}
}
int p = startWith;
for (int i = 1; i <= N; i++) {
for (int j = p; j < maxNext[p][0]; j++)
cout << words[j] << (j == maxNext[p][0] - 1 ? "\n" : " ");
p = maxNext[p][0];
}
}
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000004, M = 20;
int nxt[N][M], s[N], r, c, n;
string t[N];
int main() {
ios::sync_with_stdio(0);
cin >> n >> r >> c;
for (int i = 1; i <= n; i++) {
cin >> t[i];
s[i] = s[i - 1] + t[i].size();
}
for (int j = 0; j < M; j++) nxt[n + 1][j] = n + 1;
for (int i = 1, j = -1; i <= n; i++) {
if (j < i) j = i;
for (; j <= n && s[j] - s[i - 1] + j - i <= c; ++j)
;
nxt[i][0] = j;
}
for (int i = n; i >= 1; i--)
for (int j = 1; j < M; j++) nxt[i][j] = nxt[nxt[i][j - 1]][j - 1];
int sum = 0, p = 0, q = 0;
for (int i = 1, j; i <= n; i++) {
j = i;
for (int k = 0; k < M; k++)
if (r >> k & 1) j = nxt[j][k];
if (j - i > sum) sum = j - i, p = i, q = j;
if (j == n + 1) break;
}
for (int i = p; i != q; i = nxt[i][0]) {
for (int j = i; j < nxt[i][0]; j++)
cout << t[j] << " \n"[j + 1 == nxt[i][0]];
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
struct Doubling {
int sz, n;
vector<vector<int>> table;
Doubling(int n, long long ma = 1LL << 62) : sz(0), n(n) {
while ((1LL << sz) <= ma) ++sz;
table.assign(sz, vector<int>(n + 1, -1));
}
void set_next(int i, int x) { table[0][i] = x; }
void build() {
for (int k = 0; k < sz - 1; k++)
for (int i = 0; i < n; i++) {
if (~table[k][i]) table[k + 1][i] = table[k][table[k][i]];
}
}
int query(int i, long long t) {
for (int k = sz - 1; k >= 0; k--)
if (~i) {
if (t >> k & 1) i = table[k][i];
}
return i;
}
long long lower_bound(int s, int t) {
long long ret = s != t;
if (s > t) swap(s, t);
for (int k = sz - 1; k >= 0; k--) {
if (table[k][s] < t) ret += 1LL << k, s = table[k][s];
}
return ret;
}
};
int main() {
int n;
cin >> n;
int h, w;
cin >> h >> w;
w++;
vector<string> s(n);
for (auto& si : s) cin >> si;
vector<int> acc(n + 1);
for (int i = 0; i < n; i++) acc[i + 1] = acc[i] + (s[i].size() + 1);
Doubling dbl(n, h);
for (int left = 0, right = 0; left < n; left++) {
while (right <= n && acc[right] - acc[left] <= w) right++;
dbl.set_next(left, right - 1);
}
dbl.build();
pair<int, int> ma{-1, 0};
for (int i = 0; i < n; i++) chmax(ma, {dbl.query(i, h) - i + 1, i});
int p = ma.second;
while (h--) {
int to = dbl.query(p, 1);
while (p < to) cout << s[p] << " \n"[p == to - 1], p++;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, r, c;
int ar[1010000];
int t[20][1010000];
int p[20][1010000];
string str[1010000];
int main() {
int i, j = -1;
int t = 0;
scanf(" %d %d %d", &n, &r, &c);
for (i = 0; i < n; i++) {
cin >> str[i];
ar[i] = str[i].size();
}
for (i = 0; i < n; i++) {
if (j < i - 1) j = i - 1;
if (j == i - 1) t = 0;
while (j + 1 < n && t + (!!t) + ar[j + 1] <= c) {
j++;
t = t + (!!t) + ar[j];
}
p[0][i] = j + 1;
t -= ar[i] + 1;
}
int x, k;
int res = -1;
int resi;
for (i = 0; i < 20; i++) p[i][n] = n;
for (i = n - 1; i >= 0; i--)
for (j = 1; j < 20; j++) p[j][i] = p[j - 1][p[j - 1][i]];
for (i = 0; i < n; i++) {
x = i;
for (j = 0; j < 20; j++)
if ((1 << j) & r) x = p[j][x];
if (x - i > res) {
res = x - i;
resi = i;
}
}
k = resi;
for (i = 0; i < r; i++) {
t = 0;
int flag = 0;
while (k < n && t + (!!t) + ar[k] <= c) {
t = t + (!!t) + ar[k];
if (!flag) cout << str[k];
if (flag) cout << " " << str[k];
flag = 1;
k++;
}
printf("\n");
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int n, m, r;
string a[N + 1];
int Sum[N + 1];
vector<int> son[N + 2];
int fa[N + 2];
int stk[N + 1], top;
int ans[N + 2];
void dfs(int x) {
stk[top++] = x;
ans[x] = stk[max(0, top - 1 - r)] - x;
for (int i = 0; i < son[x].size(); i++) {
int y = son[x][i];
dfs(y);
}
top--;
}
int main() {
cin >> n >> r >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
Sum[i] = Sum[i - 1] + a[i].size() + 1;
}
fa[n + 1] = n + 1;
for (int i = n; i; i--) {
fa[i] = fa[i + 1];
while (Sum[fa[i] - 1] - Sum[i - 1] - 1 > m) fa[i]--;
if (fa[i] != i) son[fa[i]].push_back(i);
}
for (int i = 1; i <= n + 1; i++)
if (fa[i] == i) top = 0, dfs(i);
int mx = *max_element(ans + 1, ans + n + 2);
for (int i = 1; i <= n + 1; i++)
if (ans[i] == mx) {
while (r--) {
for (int j = i; j < fa[i]; j++) {
cout << a[j];
if (j < fa[i] - 1)
cout << " ";
else
cout << endl;
}
i = fa[i];
}
return 0;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<char> > ans;
vector<vector<char> > now;
vector<char> tmp;
int R, c;
int N;
int len[1010000];
int f[21][1010000];
inline int go(int l) {
int p = R;
l--;
for (int i = 20; i >= 0; i--)
if (p & (1 << i)) {
l = f[i][l + 1];
p -= (1 << i);
if (!l) return N;
}
return l;
}
inline void workit() {
int n = now.size();
N = n;
if (!n) return;
for (int i = (1); i <= (int)n; i++) len[i] = now[i - 1].size();
for (int i = (1); i <= (int)n; i++) len[i] += len[i - 1];
for (int i = (1); i <= (int)n; i++) {
int l = i;
int r = n;
int re = 0;
while (l < r) {
int mid = (l + r) >> 1;
if (len[mid] - len[i - 1] + mid - i <= c) {
re = mid;
l = mid + 1;
} else
r = mid;
}
if (len[l] - len[i - 1] + l - i <= c) re = l;
f[0][i] = re;
}
for (int j = (1); j <= (int)20; j++)
for (int i = (1); i <= (int)n; i++) {
if (!f[j - 1][i])
f[j][i] = 0;
else
f[j][i] = f[j - 1][f[j - 1][i] + 1];
}
int al, ar;
al = ar = 0;
ar = -1;
for (int i = (1); i <= (int)n; i++) {
int r = go(i);
if (r - i + 1 >= ar - al + 1) {
al = i;
ar = r;
}
}
if (ar - al + 1 > ans.size()) {
while (ans.size()) ans.pop_back();
for (int i = (al); i <= (int)ar; i++) ans.push_back(now[i - 1]);
}
for (int i = (1); i <= (int)n; i++)
for (int j = (0); j <= (int)20; j++) f[j][i] = 0;
}
int n;
int main() {
scanf("%d%d%d", &n, &R, &c);
for (int i = 1; i <= n; i++) {
while (tmp.size()) tmp.pop_back();
char p = getchar();
while (!(p <= 'z' && p >= 'a')) p = getchar();
while (p <= 'z' && p >= 'a') tmp.push_back(p), p = getchar();
if (tmp.size() > c) {
workit();
while (now.size()) now.pop_back();
} else
now.push_back(tmp);
}
workit();
for (int i = 0; i < ans.size(); i++) {
int j = i;
int tot = ans[i].size();
while (j + 1 < ans.size() && tot + ans[j + 1].size() + 1 <= c) {
tot += ans[j + 1].size() + 1;
j++;
}
for (int k = (i); k <= (int)j; k++) {
for (int p = (0); p <= (int)ans[k].size() - 1; p++)
printf("%c", ans[k][p]);
if (k != j)
printf(" ");
else
printf("\n");
}
i = j;
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int MAX_N = 1000005;
vector<int> Tree[MAX_N];
int N, R, C, Lengths[MAX_N], Stack[MAX_N];
string Words[MAX_N];
int SolutionLength, SolutionBeginning;
inline void UpdateSolution(const int beginning, const int length) {
if (length > SolutionLength) {
SolutionLength = length;
SolutionBeginning = beginning;
}
}
void DFS(const int x) {
Stack[++Stack[0]] = x;
UpdateSolution(x, Stack[max(1, Stack[0] - R)] - x);
for (auto &y : Tree[x]) DFS(y);
--Stack[0];
}
void Solve() {
for (int l = 1, r = 1, cost = -1; l <= N; ++l) {
for (; r <= N && cost + Lengths[r] + 1 <= C; ++r) cost += (Lengths[r] + 1);
if (l == r)
DFS(l);
else
Tree[r].push_back(l);
cost -= (Lengths[l] + 1);
}
DFS(N + 1);
}
void Read() {
cin >> N >> R >> C;
for (int i = 1; i <= N; ++i) {
cin >> Words[i];
Lengths[i] = static_cast<int>(Words[i].length());
}
}
void Print() {
bool newLine = true;
for (int i = SolutionBeginning, length = 0;
i < SolutionBeginning + SolutionLength; ++i) {
if (newLine) {
cout << Words[i];
newLine = false;
length = Lengths[i];
} else {
if (length + Lengths[i] + 1 <= C) {
cout << " " << Words[i];
length += (Lengths[i] + 1);
} else {
cout << "\n";
newLine = true;
--i;
}
}
}
}
int main() {
Read();
Solve();
Print();
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
string s[1000100];
int n, r, c, len[1000100], to[1000100][21], ans;
void init() {
int j = 0, l = -1;
for (int i = 0; i < n; i++) {
while (l <= c && j <= n) l += len[j++] + 1;
to[i][0] = j - 1;
l -= len[i] + 1;
}
to[n][0] = n;
}
void bz() {
for (int j = 1; (1 << j) <= r; j++)
for (int i = 0; i <= n; i++) to[i][j] = to[to[i][j - 1]][j - 1];
}
int solve(int st) {
int temp = st, now = r;
for (int i = 20; i >= 0; i--)
if (now >= (1 << i)) temp = to[temp][i], now -= (1 << i);
return temp - st;
}
void out(int st) {
int j = st, now;
for (int i = 0; i < r; i++) {
if (len[j] > c) break;
cout << s[j];
now = c - len[j];
j++;
while (now >= len[j] + 1 && j < n)
now -= len[j] + 1, cout << ' ' << s[j], j++;
cout << endl;
}
}
int main() {
cin >> n >> r >> c;
for (int i = 0; i < n; i++) cin >> s[i], len[i] = s[i].size();
init();
bz();
int ans = 0, st = 0;
for (int i = 0; i < n; i++) {
int temp = solve(i);
if (temp > ans) ans = temp, st = i;
}
if (ans > 0) out(st);
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
const int MAXN = 1000005;
const int MAXL = 6000005;
const int MAXLOGN = 21;
int n, r, c;
int totl;
char str[MAXL];
int id[MAXL];
int pos[MAXN];
int next[MAXN];
int goright[MAXLOGN][MAXN];
void init() {
scanf("%d%d%d\n", &n, &r, &c);
++c;
fgets(str, MAXL, stdin);
int now = 0;
for (int i = 0; i < n; ++i) {
pos[i] = now;
while (true) {
id[now] = i;
++now;
if (str[now - 1] == ' ' || str[now - 1] == '\n') break;
}
}
totl = now;
id[totl] = n;
pos[n] = totl;
}
void solve() {
for (int i = 0; i < n; ++i) {
int nx = pos[i] + c;
if (nx > totl) nx = totl;
next[i] = id[nx];
}
next[n] = n;
for (int i = 0; i <= n; ++i) goright[0][i] = next[i];
for (int i = 1; i < MAXLOGN; ++i)
for (int j = 0; j <= n; ++j)
goright[i][j] = goright[i - 1][goright[i - 1][j]];
int ans = -1;
int ansp;
for (int i = 0; i < n; ++i) {
int xx = i;
for (int j = 0; j < MAXLOGN; ++j)
if ((r >> j) & 1) xx = goright[j][xx];
if (xx - i > ans) {
ans = xx - i;
ansp = i;
}
}
for (int i = 0, x = ansp; i < r; ++i) {
int y = next[x];
if (x == y) break;
printf("%.*s\n", pos[y] - pos[x] - 1, str + pos[x]);
x = y;
}
}
int main() {
init();
solve();
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int maxn = 1e6 + 5;
const int logn = 21;
int n, c, r, ans;
int l[maxn], res[maxn], sum[maxn];
int st[maxn][logn];
string s[maxn];
int main() {
cin >> n >> r >> c;
for (int i = (0); i < (n); ++i) cin >> s[i], l[i] = s[i].size();
for (int i = (0); i < (n); ++i) sum[i] = l[i] + (i ? sum[i - 1] + 1 : 0);
for (int i = (0); i < (n); ++i) {
int &pos = st[i][0];
pos = upper_bound(sum, sum + n, (i ? (sum[i - 1] + 1) : 0) + c) - sum;
pos = max(pos, i);
}
for (int j = (1); j < (logn); ++j)
for (int i = (0); i < (n); ++i) {
if (st[i][j - 1] == n)
st[i][j] = n;
else {
st[i][j] = st[st[i][j - 1]][j - 1];
}
}
st[n][0] = n;
for (int i = (0); i < (n); ++i) {
int j = i;
for (int k = logn - 1; k >= 0; --k)
if (r >> k & 1) {
j = st[j][k];
if (j == n) break;
}
ans = max(ans, j - i);
res[i] = j;
}
for (int i = (0); i < (n); ++i)
if (res[i] - i == ans) {
int len = 0;
for (int j = (i); j < (res[i]); ++j) {
if (j == i) {
cout << s[j];
len += l[j];
continue;
}
if (len + l[j] + 1 > c) {
puts("");
cout << s[j];
len = l[j];
} else {
cout << " " << s[j];
len += l[j] + 1;
}
}
return 0;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000005;
const int Maxm = 22;
int n, r, c;
string w[Maxn];
int sum[Maxn];
int E[Maxn][Maxm];
int best = 0, bi = n;
int main() {
std::ios_base::sync_with_stdio(0);
cin >> n >> r >> c;
for (int i = 0; i < n; i++) {
cin >> w[i];
sum[i + 1] = sum[i] + w[i].length();
}
for (int i = 0; i < n; i++) {
int lef = i + 1, rig = n, res = i;
while (lef <= rig) {
int mid = lef + rig >> 1;
if (sum[mid] - sum[i] + mid - i - 1 <= c) {
res = mid;
lef = mid + 1;
} else
rig = mid - 1;
}
E[i][0] = res;
}
fill(E[n], E[n] + Maxm, n);
for (int j = 1; j < Maxm; j++)
for (int i = 0; i < n; i++) E[i][j] = E[E[i][j - 1]][j - 1];
for (int i = 0; i < n; i++) {
int cur = i, lef = r;
for (int j = Maxm - 1; j >= 0; j--)
if (1 << j <= lef) {
cur = E[cur][j];
lef -= 1 << j;
}
if (cur - i > best) {
best = cur - i;
bi = i;
}
}
while (bi < n && r) {
for (int i = bi; i < E[bi][0]; i++)
cout << w[i] << (i + 1 < E[bi][0] ? ' ' : '\n');
bi = E[bi][0];
r--;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
int f[20][1000050];
char s[6000050];
int st[1000050], ed[1000050];
int n, r, c;
int main() {
int i, j, h, t, mid, x, ans;
scanf("%d%d%d", &n, &r, &c);
for (i = 1; i <= n; i++) {
if (i == 1)
st[i] = 1;
else
st[i] = ed[i - 1] + 2;
scanf("%s", s + st[i]);
ed[i] = st[i] + strlen(s + st[i]) - 1;
}
for (i = 1; i <= n; i++) {
h = i - 1;
t = n;
while (h < t) {
mid = (h + t + 1) / 2;
if (ed[mid] - st[i] + 1 <= c)
h = mid;
else
t = mid - 1;
}
f[0][i] = h;
}
for (i = 0; i <= 19; i++) f[i][n + 1] = n;
for (i = 1; i <= 19; i++)
for (j = 1; j <= n; j++) f[i][j] = f[i - 1][f[i - 1][j] + 1];
ans = -1;
for (i = 1; i <= n; i++) {
x = i - 1;
for (j = 19; j >= 0; j--)
if (r & (1 << j)) x = f[j][x + 1];
if (x - i + 1 > ans) {
ans = x - i + 1;
t = i;
}
}
x = t;
for (i = 1; i <= r; i++) {
for (j = x; j <= f[0][x]; j++) {
printf("%s", s + st[j]);
if (j < f[0][x]) printf(" ");
}
printf("\n");
x = f[0][x] + 1;
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, r, c;
string s[1 << 20];
char a[1 << 23];
int sum[1 << 20], nxt[1 << 20][25];
int main() {
cin >> n >> r >> c;
++c;
sum[0] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%s", a);
s[i] = a;
sum[i] = sum[i - 1] + s[i].size() + 1;
}
for (int i = 1; i <= n; ++i) {
nxt[i][0] = upper_bound(sum + 1, sum + n + 1, sum[i - 1] + c) - sum;
}
nxt[n + 1][0] = n + 1;
for (int j = 1; j < 25; ++j) {
for (int i = 1; i <= n; ++i) nxt[i][j] = nxt[nxt[i][j - 1]][j - 1];
nxt[n + 1][j] = n + 1;
}
int mx = 0, pos = 0;
for (int i = 1; i <= n; ++i) {
int nx = i;
for (int j = 25; j >= 0; --j) {
if (r & (1 << j)) nx = nxt[nx][j];
}
if (mx < nx - i) {
mx = nx - i;
pos = i;
}
}
for (int i = 0; i < r && pos <= n; ++i) {
for (int j = pos; j < nxt[pos][0]; ++j) {
for (int k = 0; k < s[j].size(); ++k) printf("%c", s[j][k]);
if (j != nxt[pos][0] - 1) printf(" ");
}
if (pos == nxt[pos][0]) break;
pos = nxt[pos][0];
if (pos == n + 1) break;
printf("\n");
}
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
int N, R, C;
string S[1000010];
int A[1000010];
int ASum[1000010];
int to[1000010];
int crt[1000010], nxt[1000010];
void solve(int e) {
int i;
if (e == 0) {
for (i = 0; i <= N; ++i) {
crt[i] = i;
}
return;
}
solve(e / 2);
for (i = 0; i <= N; ++i) {
nxt[i] = crt[crt[i]];
}
if (e % 2 != 0) {
for (i = 0; i <= N; ++i) {
crt[i] = to[nxt[i]];
}
} else {
for (i = 0; i <= N; ++i) {
crt[i] = nxt[i];
}
}
}
char buf[(int)1e7];
int main() {
int i, j, r;
for (; ~scanf("%d%d%d", &N, &R, &C);) {
for (i = 0; i < N; ++i) {
scanf("%s", buf);
S[i] = buf;
}
for (i = 0; i < N; ++i) {
A[i] = S[i].size() + 1;
}
for (i = 0; i < N; ++i) {
ASum[i + 1] = ASum[i] + A[i];
}
for (j = 0, i = 0; i <= N; ++i) {
for (; j <= N && ASum[j] - ASum[i] <= C + 1; ++j)
;
--j;
to[i] = j;
}
solve(R);
int opt = -1;
int im = -1;
for (i = 0; i <= N; ++i) {
if (opt < crt[i] - i) {
opt = crt[i] - i;
im = i;
}
}
for (r = 0; r < R; ++r) {
if (im == to[im]) {
break;
}
for (i = im; i < to[im]; ++i) {
if (i > im) printf(" ");
printf("%s", S[i].c_str());
}
puts("");
im = to[im];
}
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
namespace fastio {
char in[100000];
int itr = 0, llen = 0;
char get() {
if (itr == llen) llen = fread(in, 1, 100000, stdin), itr = 0;
if (llen == 0) return EOF;
return in[itr++];
}
char out[100000];
int itr2 = 0;
void put(char c) {
out[itr2++] = c;
if (itr2 == 100000) {
fwrite(out, 1, 100000, stdout);
itr2 = 0;
}
}
int clear() {
fwrite(out, 1, itr2, stdout);
itr2 = 0;
return 0;
}
int getint() {
int ret = 0;
char ch = get();
while (ch < '0' || ch > '9') {
ch = get();
if (ch == '-') return -getint();
}
while ('0' <= ch && ch <= '9') {
ret = ret * 10 - 48 + ch;
ch = get();
}
return ret;
}
string getstr() {
string ret = "";
char ch = get();
while (ch == ' ' || ch == '\n') ch = get();
while (ch != ' ' && ch != '\n') ret.push_back(ch), ch = get();
return ret;
}
void putstr(string s) {
for (int i = 0; i < s.size(); i++) put(s[i]);
}
void putint(int x) {
if (x < 0) {
put('-');
putint(-x);
return;
}
if (x == 0) {
put('0');
return;
}
char c[40];
int pos = 0;
while (x) {
c[pos++] = '0' + x % 10;
x /= 10;
}
for (int i = pos - 1; i >= 0; i--) put(c[i]);
put(' ');
}
void putln(int x) {
if (x < 0) {
put('-');
putln(-x);
return;
}
if (x == 0) {
put('0');
put('\n');
return;
}
char c[40];
int pos = 0;
while (x) {
c[pos++] = '0' + x % 10;
x /= 10;
}
for (int i = pos - 1; i >= 0; i--) put(c[i]);
put('\n');
}
} // namespace fastio
using namespace fastio;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const int mod = 1000000007;
inline string getstr(string &s, int l, int r) {
string ret = "";
for (int i = l; i <= r; i++) ret.push_back(s[i]);
return ret;
}
int modpow(int x, int y, int md = mod) {
if (y == 0) return 1;
int ret = modpow(x, y >> 1, md);
ret = (long long)ret * ret % md;
if (y & 1) ret = (long long)ret * x % md;
return ret;
}
int n, r, c;
string s[1000005];
int len[1000005], nxt[1000005];
int pref[1000005];
vector<int> g[1000005];
void add_edge(int x, int y) { g[y].push_back(x); }
bool vis[1000005];
vector<int> stk;
int ans = -1, st;
void dfs(int x) {
vis[x] = 1;
stk.push_back(x);
int sub = min((int)stk.size(), r + 1);
int pos = stk.size() - sub;
if (stk[pos] - x > ans) {
ans = stk[pos] - x;
st = x;
}
for (int i = 0; i < g[x].size(); i++) {
dfs(g[x][i]);
}
stk.pop_back();
}
int main() {
n = getint();
r = getint();
c = getint() + 1;
for (int i = 1; i <= n; i++) s[i] = getstr();
for (int i = 1; i <= n; i++) len[i] = s[i].size() + 1;
for (int i = 1; i <= n; i++) pref[i] = pref[i - 1] + len[i];
for (int i = 1; i <= n; i++) {
if (len[i] > c) continue;
int L = i - 1, R = n + 1;
while (R - L > 1) {
int mid = L + R >> 1;
if (pref[mid] - pref[i - 1] <= c)
L = mid;
else
R = mid;
}
if (0) cout << R << "--->" << i << " value=" << R - i << endl;
nxt[i] = R;
add_edge(i, R);
}
for (int i = n + 1; i >= 1; i--)
if (!vis[i]) dfs(i);
if (0) cout << st << endl;
for (int line = 1; line <= r; line++) {
if (len[st] > c) break;
for (int i = st; i < nxt[st]; i++) {
if (i != st) put(' ');
putstr(s[i]);
}
put('\n');
st = nxt[st];
}
clear();
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, a, b, p[maxn], sum[maxn], nex[maxn][21], ans, l;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
string s[maxn];
int main() {
n = read(), a = read(), b = read() + 1;
for (int i = 1; i <= n; i++) cin >> s[i], p[i] = s[i].size() + 1;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + p[i];
for (int i = 1; i <= n; i++)
nex[i][0] = upper_bound(sum + 1, sum + n + 1, sum[i - 1] + b) - sum;
nex[n + 1][0] = n + 1;
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= n + 1; j++) nex[j][i] = nex[nex[j][i - 1]][i - 1];
for (int i = 1; i <= n; i++) {
int r = i;
for (int j = 0; j <= 20; j++)
if (a >> j & 1) r = nex[r][j];
if (ans < r - i) ans = r - i, l = i;
}
while (ans) {
for (int i = l; i < nex[l][0]; i++)
cout << s[i] << (i == nex[l][0] - 1 ? '\n' : ' ');
ans -= nex[l][0] - l;
l = nex[l][0];
}
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
string text[1000001];
int range[1000001], lines[1000001];
vector<int> followers[1000001];
int n, r, c;
int maxMax(-1), maxInd(0);
void setMaxNums(void) {
int total(0), j(-1);
for (int i = 0; i < n; ++i) {
if (j < i) total = text[j = i].size();
while (j < n - 1 && text[j + 1].size() + 1 + total <= (unsigned int)c) {
total += text[j + 1].size() + 1;
++j;
}
lines[i] = range[i] = total <= c ? j - i + 1 : -1;
total -= text[i].size() + 1;
}
}
void oneThatFollows(void) {
for (int i = 0; i < n; ++i) followers[i + range[i]].push_back(i);
}
void findLines(int dest) {
vector<int> stInd, path;
stInd.push_back(-1);
stInd.push_back(dest);
path.push_back(0);
while (!stInd.empty()) {
int tmp = stInd.back();
stInd.pop_back();
if (tmp == -1) {
path.pop_back();
continue;
}
stInd.push_back(-1);
path.push_back(path.back() + range[tmp]);
while (!followers[tmp].empty()) {
stInd.push_back(followers[tmp].back());
followers[tmp].pop_back();
}
int pre((int)(path.size()) - r - 1);
lines[tmp] = path.back() - (pre < 0 ? 0 : path[pre]);
}
}
void endAllEnders(void) {
for (int i = n - 1; i >= 0; --i)
if (!followers[i].empty()) findLines(i);
}
void findMax(void) {
for (int i = 0; i < n; ++i)
if (maxMax < lines[i]) {
maxMax = lines[i];
maxInd = i;
}
}
void printOne(int i) {
if (range[i] == -1) return;
cout << text[i];
for (int j = 1; j < range[i]; ++j) cout << " " << text[i + j];
cout << '\n';
}
void printRight(void) {
int tmpInd(maxInd);
for (int i = 0; i < r; ++i) {
if (tmpInd >= n || range[tmpInd] == -1) break;
printOne(tmpInd);
tmpInd += range[tmpInd];
}
}
int main(void) {
cin >> n >> r >> c;
for (int i = 0; i < n; ++i) cin >> text[i];
setMaxNums();
oneThatFollows();
endAllEnders();
findMax();
printRight();
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
const int MAXN = 1000005;
const int MAXL = 6000005;
const int MAXLOGN = 21;
int n, r, c;
int totl;
char str[MAXL];
int id[MAXL];
int pos[MAXN];
int next[MAXN];
int goright[MAXLOGN][MAXN];
void init() {
scanf("%d%d%d\n", &n, &r, &c);
++c;
fgets(str, MAXL, stdin);
int now = 0;
for (int i = 0; i < n; ++i) {
pos[i] = now;
while (true) {
id[now] = i;
++now;
if (str[now - 1] == ' ' || str[now - 1] == '\n' || str[now - 1] == '\0')
break;
}
}
totl = now;
id[totl] = n;
pos[n] = totl;
}
void solve() {
for (int i = 0; i < n; ++i) {
int nx = pos[i] + c;
if (nx > totl) nx = totl;
next[i] = id[nx];
}
next[n] = n;
for (int i = 0; i <= n; ++i) goright[0][i] = next[i];
for (int i = 1; i < MAXLOGN; ++i)
for (int j = 0; j <= n; ++j)
goright[i][j] = goright[i - 1][goright[i - 1][j]];
int ans = -1;
int ansp;
for (int i = 0; i < n; ++i) {
int xx = i;
for (int j = 0; j < MAXLOGN; ++j)
if ((r >> j) & 1) xx = goright[j][xx];
if (xx - i > ans) {
ans = xx - i;
ansp = i;
}
}
for (int i = 0, x = ansp; i < r; ++i) {
int y = next[x];
if (x == y) break;
printf("%.*s\n", pos[y] - pos[x] - 1, str + pos[x]);
x = y;
}
}
int main() {
init();
solve();
return 0;
}
| 8 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100 + 10;
const int Mod = (int)1e9 + 7;
int n, m;
int g[MAX][MAX], can[MAX][MAX];
vector<int> p[MAX][MAX];
int get(vector<int> &before, int kind, int could, int have) {
int j;
int now = 0, cc = have;
for (; now < (int)before.size(); now++) {
if (now + 1 == (int)before.size()) break;
int a = before[now];
int b = before[now + 1];
if (g[a][b] != kind || (!could && can[a][b])) return 0;
vector<int> &nL = p[a][b];
for ((j) = (0); (j) != ((int)nL.size()); ++(j)) {
if (cc < (int)before.size()) {
if (nL[j] == before[cc])
cc++;
else
return 0;
} else {
while (j < (int)nL.size()) {
before.push_back(nL[j++]);
if ((int)before.size() > 2 * n + 1) return 0;
}
cc = before.size();
break;
}
}
}
return cc == (int)before.size();
}
int isCan(int a, int b) {
int i;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) return 1;
return 0;
}
int f_Before[MAX][MAX][MAX], f_After[MAX][MAX][MAX], tmp[MAX][MAX][MAX];
int Before[MAX][MAX], After[MAX][MAX];
int ans[MAX];
void work(int u, int kind, int f[MAX][MAX][MAX]) {
int v;
for ((v) = (1); (v) <= (n); ++(v))
if (g[u][v] == kind && !can[v][u]) {
vector<int> after;
after.push_back(u);
after.push_back(v);
if (!get(after, kind, kind != 2, 1)) continue;
int Len = after.size();
f[u][after[Len - 1]][Len - 1]++;
}
}
void add(int &a, int b) {
a += b;
if (a >= Mod) a -= Mod;
}
void work2(int a, int b) {
int i, j;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) {
vector<int> before, after;
for (j = i; j >= 0; --j) before.push_back(L[j]);
for (j = i + 1; j < len; ++j) after.push_back(L[j]);
if (get(before, 2, 0, before.size()) && get(after, 1, 1, after.size())) {
reverse(before.begin(), before.end());
int A = before[0];
int B = after[after.size() - 1];
int Len = before.size() + after.size() - 1;
int k, l, o;
for ((l) = (1); (l) <= (n); ++(l))
for ((o) = (0); (o) <= (2 * n); ++(o))
if (tmp[A][l][o])
for ((k) = (1); (k) <= (n); ++(k))
if (g[k][l] == 1 && p[k][l].size() == 0 && Len + 1 + o <= 2 * n)
add(f_After[k][B][Len + 1 + o], tmp[A][l][o]);
} else
return;
}
return;
}
int tot = 0, First;
void Dp1(int f[MAX][MAX][MAX], int after[MAX][MAX]) {
int i, j, k, l, o;
memset(tmp, 0, sizeof tmp);
for ((i) = (1); (i) <= (n); ++(i)) tmp[i][i][0] = 1;
int up = 2 * n;
for ((l) = (1); (l) <= (up); ++(l))
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((o) = (0); (o) <= (l); ++(o))
if (f[i][j][o])
for ((k) = (1); (k) <= (n); ++(k))
if (tmp[j][k][l - o])
add(tmp[i][k][l],
(long long)f[i][j][o] * tmp[j][k][l - o] % Mod);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((l) = (0); (l) <= (2 * n); ++(l)) add(after[i][l], tmp[i][j][l]);
}
void Dp2(int f[MAX][MAX][MAX], int after[MAX][MAX]) {
int i, j, k, l;
for ((i) = (1); (i) <= (n); ++(i)) after[i][0] = 1;
int up = 2 * n;
for ((l) = (1); (l) <= (up); ++(l))
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
for ((k) = (0); (k) != (l); ++(k))
add(After[i][l], (long long)f[i][j][l - k] * After[j][k] % Mod);
}
void check(int a, int b) {
int i, j;
vector<int> &L = p[a][b];
int len = L.size();
for ((i) = (0); (i) <= (len - 2); ++(i))
if (L[i] == a && L[i + 1] == b) {
vector<int> before, after;
for (j = i; j >= 0; --j) before.push_back(L[j]);
for (j = i + 1; j < len; ++j) after.push_back(L[j]);
if (get(before, 2, 0, before.size()) && get(after, 1, 1, after.size())) {
reverse(before.begin(), before.end());
int A = before[0];
int B = after[after.size() - 1];
int Len = before.size() + after.size() - 1;
int l1, l2;
for ((l1) = (0); (l1) <= (2 * n); ++(l1))
for ((l2) = (0); (l2) <= (2 * n); ++(l2))
if (l1 + l2 + Len <= 2 * n)
add(ans[l1 + l2 + Len],
(long long)Before[A][l1] * After[B][l2] % Mod);
} else
return;
}
return;
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
for ((i) = (1); (i) <= (m); ++(i)) {
int a, b;
scanf("%d%d", &a, &b);
if (!First) First = a;
g[a][b] = 1;
g[b][a] = 2;
int k, first;
scanf("%d", &k);
while (k--) {
scanf("%d", &first);
p[a][b].push_back(first);
}
p[b][a] = p[a][b];
reverse(p[b][a].begin(), p[b][a].end());
}
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && isCan(i, j)) can[j][i] = can[i][j] = 1;
for ((i) = (1); (i) <= (n); ++(i)) work(i, 1, f_After);
for ((i) = (1); (i) <= (n); ++(i)) work(i, 2, f_Before);
Dp1(f_Before, Before);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && can[i][j] == 1) work2(i, j);
Dp2(f_After, After);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j))
if (g[i][j] == 1 && can[i][j] == 1) check(i, j);
for ((i) = (1); (i) <= (2 * n); ++(i)) cout << ans[i] << endl;
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55, mod = 1000000007;
struct _two {
int a, b;
} edge[N * N], aedge[N * N];
int vis[N * N][N];
int n, m;
int st[N], ast[N], qu[N + N + N], aqu[N + N + N];
int f[N + N][N][N], t[N + N][N][N], g[N + N][N];
vector<_two> tail[N], head[N];
void Init() {
scanf("%d%d", &n, &m);
int x, y, tot = 0;
memset(st, 0, sizeof(st));
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
++tot;
edge[tot] = (_two){y, st[x]};
st[x] = tot;
aedge[tot] = (_two){x, ast[y]};
ast[y] = tot;
scanf("%d", &vis[tot][0]);
for (int j = 1; j <= vis[tot][0]; j++) scanf("%d", &vis[tot][j]);
}
}
int dfs(int x) {
int num = 0;
while (num < qu[0] && qu[0] <= n + n) {
++num;
bool flag = 0;
for (int i = st[x]; i; i = edge[i].b)
if (edge[i].a == qu[num]) {
flag = 1;
for (int j = 1; j <= vis[i][0]; j++) qu[++qu[0]] = vis[i][j];
break;
}
if (!flag) return -1;
x = qu[num];
}
if (qu[0] > n + n)
return -1;
else
return qu[0];
}
int adfs(int x) {
int num = 0;
while (num < aqu[0] && aqu[0] <= n + n) {
++num;
bool flag = 0;
for (int i = ast[x]; i; i = aedge[i].b)
if (aedge[i].a == aqu[num]) {
flag = 1;
for (int j = vis[i][0]; j >= 1; j--) aqu[++aqu[0]] = vis[i][j];
break;
}
if (!flag) return -1;
x = aqu[num];
}
if (aqu[0] > n + n)
return -1;
else
return aqu[0];
}
void Work() {
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; i++) {
head[i].clear();
tail[i].clear();
}
for (int i = 1; i <= n; i++)
for (int j = st[i]; j; j = edge[j].b) {
for (int k = 2; k <= vis[j][0]; k++)
if (vis[j][k] == edge[j].a && vis[j][k - 1] == i) {
aqu[0] = k - 2;
for (int l = k - 2; l >= 1; l--) aqu[k - 1 - l] = vis[j][l];
int num1 = adfs(i);
qu[0] = vis[j][0] - k;
for (int l = k + 1; l <= vis[j][0]; l++) qu[l - k] = vis[j][l];
int num2 = dfs(edge[j].a);
if (num1 == -1 || num2 == -1) break;
if (!num1) aqu[num1] = i;
if (!num2) qu[num2] = edge[j].a;
if (num1 + num2 + 1 <= n + n)
f[num1 + num2 + 1][aqu[num1]][qu[num2]]++;
break;
}
if (vis[j][1] == edge[j].a) {
qu[0] = vis[j][0] - 1;
for (int l = 2; l <= vis[j][0]; l++) qu[l - 1] = vis[j][l];
int num = dfs(edge[j].a);
if (num != -1) {
if (!num) qu[num] = edge[j].a;
tail[i].push_back((_two){qu[num], num + 1});
}
}
if (vis[j][vis[j][0]] == i) {
aqu[0] = vis[j][0] - 1;
for (int l = vis[j][0] - 1; l >= 1; l--) aqu[vis[j][0] - l] = vis[j][l];
int num = adfs(i);
if (num != -1) {
if (!num) aqu[num] = i;
head[edge[j].a].push_back((_two){aqu[num], num + 1});
}
}
}
memset(t, 0, sizeof(t));
memset(g, 0, sizeof(g));
for (int l = 1; l <= n + n; l++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (!f[l][i][j]) continue;
for (vector<_two>::iterator k = tail[j].begin(); k != tail[j].end();
k++)
if (k->b + l <= n + n)
f[l + k->b][i][k->a] = (f[l + k->b][i][k->a] + f[l][i][j]) % mod;
}
for (int l = 1; l <= n + n; l++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (!f[l][i][j]) continue;
for (vector<_two>::iterator k = head[i].begin(); k != head[i].end();
k++)
if (k->b + l <= n + n)
f[l + k->b][k->a][j] = (f[l + k->b][k->a][j] + f[l][i][j]) % mod;
}
for (int l = 1; l <= n + n; l++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (!f[l][i][j]) continue;
g[l][j] = (g[l][j] + f[l][i][j]) % mod;
for (int k = ast[i]; k; k = aedge[k].b)
if (!vis[k][0])
t[l + 1][aedge[k].a][j] =
(t[l + 1][aedge[k].a][j] + f[l][i][j]) % mod;
}
for (int l = 1; l <= n + n; l++)
for (int i = 1; i <= n; i++)
if (g[l][i])
for (int k = 1; k <= n; k++)
for (int l1 = 1; l1 <= n + n - l; l1++)
if (t[l1][i][k])
g[l + l1][k] =
((long long)g[l][i] * t[l1][i][k] + g[l + l1][k]) % mod;
for (int i = 1; i <= n + n; i++) {
int sum = 0;
for (int j = 1; j <= n; j++) sum = (sum + g[i][j]) % mod;
printf("%d\n", sum);
}
}
int main() {
Init();
Work();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 105;
int partial_solution[2][2][N][N][N];
int final_solution[N][N][2];
int n, m;
vector<int> visions[N * N];
int startnode[N * N], endnode[N * N];
int closed_chain[N][N][N];
int open_chain[N][N][N];
int edgeID[N][N];
inline void add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
pair<int, int> find_chains(vector<int> &temp_chain, int x,
bool same_direction) {
int curr_index = 0;
while (curr_index + 1 <= temp_chain.size()) {
int y = temp_chain[curr_index];
int current_edge = edgeID[x][y];
if (!current_edge || temp_chain.size() > 2 * n ||
(current_edge > m) != same_direction)
return pair<int, int>(10086, -1);
for (int j = (0); j <= (int)visions[current_edge].size() - 1; j++)
temp_chain.push_back(visions[current_edge][j]);
x = y;
curr_index++;
}
return pair<int, int>(temp_chain.size(), x);
}
void input() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (int)m; i++) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
edgeID[x][y] = i;
startnode[i] = x;
endnode[i] = y;
for (int j = (1); j <= (int)k; j++) {
int v;
scanf("%d", &v);
visions[i].push_back(v);
}
edgeID[y][x] = i + m;
startnode[i + m] = y;
endnode[i + m] = x;
for (int j = (k - 1); j >= (int)0; j--)
visions[i + m].push_back(visions[i][j]);
if (k == 0) partial_solution[0][0][x][y][1]++;
}
}
void build_chain_table(bool same_direction) {
memset(closed_chain, 0, sizeof closed_chain);
memset(open_chain, 0, sizeof open_chain);
for (int i = (1); i <= (int)2 * m; i++)
if ((i <= m) ^ same_direction) {
for (int j = (0); j <= (int)visions[i].size() - 1; j++)
if (visions[i][j] == startnode[i]) {
vector<int> temprory_forward_chain, temprory_backward_chain;
for (int k = (j - 1); k >= (int)0; k--)
temprory_forward_chain.push_back(visions[i][k]);
pair<int, int> forward_chain = find_chains(
temprory_forward_chain, startnode[i], same_direction ^ 1);
if (forward_chain.first > 2 * n) continue;
if (j + 1 == visions[i].size())
open_chain[forward_chain.second][endnode[i]]
[forward_chain.first + 1]++;
else {
if (visions[i][j + 1] != endnode[i]) continue;
for (int k = (j + 2); k <= (int)visions[i].size() - 1; k++)
temprory_backward_chain.push_back(visions[i][k]);
pair<int, int> backward_chain = find_chains(
temprory_backward_chain, endnode[i], same_direction);
if (backward_chain.first + 1 + forward_chain.first <= 2 * n)
closed_chain[forward_chain.second][backward_chain.second]
[backward_chain.first + 1 + forward_chain.first]++;
}
}
}
}
void build_partial_dp() {
build_chain_table(0);
for (int i = (1); i <= (int)n; i++)
for (int j = (1); j <= (int)n; j++)
for (int k = (1); k <= (int)2 * n; k++) {
partial_solution[1][1][i][j][k] = closed_chain[i][j][k];
partial_solution[1][0][i][j][k] = open_chain[i][j][k];
}
build_chain_table(1);
for (int i = (1); i <= (int)n; i++)
for (int j = (1); j <= (int)n; j++)
for (int k = (1); k <= (int)2 * n; k++)
partial_solution[0][1][j][i][k] = open_chain[i][j][k];
}
void final_dp_solve() {
for (int i = (1); i <= (int)n; i++)
for (int j = (1); j <= (int)n; j++)
for (int k = (1); k <= (int)2 * n; k++)
for (int v = (0); v <= (int)1; v++)
add(final_solution[k][j][v], partial_solution[1][v][i][j][k]);
int ans;
for (int k = (1); k <= (int)n * 2; k++) {
ans = 0;
for (int i = (1); i <= (int)n; i++) {
add(ans, final_solution[k][i][1]);
for (int mid = (0); mid <= (int)1; mid++)
if (final_solution[k][i][mid]) {
for (int ed = (0); ed <= (int)1; ed++)
for (int zd = (1); zd <= (int)n; zd++)
for (int len = (1); len <= (int)2 * n - k; len++)
add(final_solution[k + len][zd][ed],
final_solution[k][i][mid] * 1ll *
partial_solution[mid ^ 1][ed][i][zd][len] % MOD);
}
}
printf("%d\n", ans);
}
}
int main() {
input();
build_partial_dp();
final_dp_solve();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, m, ans[55 << 1], dp[55 << 1][2][55];
vector<int> a[55][55], t[2][2][55][55];
bool G[55][55];
bool ext_front(deque<int> &q, deque<int>::iterator it) {
while (it != q.begin() && q.size() <= (n << 1 | 1)) {
auto nxt = it - 1;
if (!G[*nxt][*it]) return false;
q.insert(q.begin(), a[*nxt][*it].begin(), a[*nxt][*it].end());
--it;
}
return q.size() <= (n << 1 | 1);
}
bool ext_back(deque<int> &q, deque<int>::iterator it) {
while (it + 1 != q.end() && q.size() <= (n << 1 | 1)) {
auto nxt = it + 1;
if (!G[*it][*nxt]) return false;
q.insert(q.end(), a[*it][*nxt].begin(), a[*it][*nxt].end());
++it;
}
return q.size() <= (n << 1 | 1);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read(), k = read();
G[u][v] = true;
while (k--) {
a[u][v].push_back(read());
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (G[i][j] && !a[i][j].empty() && a[i][j].back() == i) {
deque<int> q(a[i][j].begin(), a[i][j].end());
if (ext_front(q, --q.end())) t[0][0][q.front()][j].push_back(q.size());
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (G[i][j] && !a[i][j].empty() && a[i][j].front() == j) {
deque<int> q(a[i][j].begin(), a[i][j].end());
if (ext_back(q, q.begin())) t[1][1][i][q.back()].push_back(q.size());
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (G[i][j] && !a[i][j].empty()) {
deque<int> q(a[i][j].begin(), a[i][j].end());
auto p = find(q.begin(), q.end(), i);
if (p == q.end() || p + 1 == q.end() || *(p + 1) != j) continue;
if (ext_front(q, p) && ext_back(q, p + 1)) {
t[0][1][q.front()][q.back()].push_back(q.size() - 1);
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (G[i][j] && a[i][j].empty()) t[1][0][i][j].push_back(1);
for (int i = 1; i <= n; ++i) {
dp[0][0][i] = 1;
}
for (int len = 0; len < (n << 1); ++len)
for (int p = 0; p <= 1; ++p)
for (int i = 1; i <= n; ++i) {
int w = dp[len][p][i];
if (!w) continue;
for (int q = 0; q <= 1; ++q) {
for (int j = 1; j <= n; ++j) {
for (int z : t[p][q][i][j]) {
if (len + z <= (n << 1))
dp[len + z][q][j] = (dp[len + z][q][j] + w) % mod;
}
}
}
}
for (int len = 1; len <= (n << 1); ++len) {
int ans = 0;
for (int i = 1; i <= n; ++i) {
ans = (ans + dp[len][1][i]) % mod;
}
printf("%d\n", ans);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
const int N = 51, Mod = 1e9 + 7;
inline void Add(int &x, int dat) {
if ((x += dat) >= Mod) x -= Mod;
}
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
int edg[N][N], a[N][N][N * 2], ac[N][N][N * 2], acb[N][N][N * 2],
dacb[N][N][N * 2], ans[N][N * 2];
std::vector<int> E[N][N], A[N][N], B[N][N], C[N][N];
int main() {
int n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read(), k = read();
edg[u][v] = true, E[u][v].resize(k);
for (int i = 0; i < k; ++i) E[u][v][i] = read();
}
std::vector<int> Res;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int k = 0; k + 1 < E[i][j].size(); ++k)
if (E[i][j][k] == i && E[i][j][k + 1] == j) {
std::vector<int> cur = E[i][j], tmp;
while (true) {
if (cur.size() > n * 2 + 1) break;
int flg = false;
tmp.clear();
for (int i = 0; i + 1 < cur.size(); ++i) {
int u = cur[i], v = cur[i + 1];
if (!edg[u][v]) {
flg = true;
break;
}
for (int w = 0; w < E[u][v].size(); ++w)
tmp.push_back(E[u][v][w]);
}
if (flg) break;
if (tmp == cur) {
if (Res.empty()) Res = tmp;
C[cur[0]][cur.back()].push_back(cur.size() - 1);
break;
}
std::swap(tmp, cur);
}
break;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (E[i][j].size() && E[i][j].back() == i) {
std::vector<int> cur, tmp;
cur.push_back(i);
while (true) {
if (cur.size() > 2 * n + 1) break;
int flg = false;
tmp = E[cur[0]][j];
std::reverse(tmp.begin(), tmp.end());
for (int i = 0; i + 1 < cur.size(); ++i) {
int u = cur[i + 1], v = cur[i];
if (!edg[u][v]) {
flg = true;
break;
}
for (int w = E[u][v].size() - 1; w >= 0; --w)
tmp.push_back(E[u][v][w]);
}
if (flg) break;
if (tmp == cur) {
A[cur.back()][j].push_back(cur.size());
break;
}
std::swap(tmp, cur);
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (E[i][j].size() && E[i][j][0] == j) {
std::vector<int> cur, tmp;
cur.push_back(j);
while (true) {
if (cur.size() > 2 * n + 1) break;
int flg = false;
tmp = E[i][cur[0]];
for (int i = 0; i + 1 < cur.size(); ++i) {
int u = cur[i], v = cur[i + 1];
if (!edg[u][v]) {
flg = true;
break;
}
for (int w = 0; w < E[u][v].size(); ++w) tmp.push_back(E[u][v][w]);
}
if (flg) break;
if (tmp == cur) {
B[i][cur.back()].push_back(cur.size());
break;
}
std::swap(tmp, cur);
}
}
for (int i = 1; i <= n; ++i) a[i][i][0] = 1;
for (int l = 0; l <= n * 2; ++l)
for (int s = 1; s <= n; ++s)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (auto x : A[i][j])
if (x + l <= 2 * n) Add(a[s][j][l + x], a[s][i][l]);
for (int l = 0; l <= n * 2; ++l)
for (int s = 1; s <= n; ++s)
for (int i = 0; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (auto x : C[i][j])
if (x + l <= 2 * n) Add(ac[s][j][l + x], a[s][i][l]);
memcpy(acb, ac, sizeof(ac));
for (int l = 0; l <= n * 2; ++l)
for (int s = 1; s <= n; ++s)
for (int i = 0; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (auto x : B[i][j])
if (x + l <= 2 * n) Add(acb[s][j][l + x], acb[s][i][l]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int l = 1; l <= 2 * n; ++l) Add(ans[j][l], acb[i][j][l]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (edg[i][j] && E[i][j].empty())
for (int k = 1; k <= n; ++k)
for (int l = 0; l <= n * 2 - 1; ++l)
Add(dacb[i][k][l + 1], acb[j][k][l]);
for (int l = 1; l <= n * 2; ++l)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
for (int L = 1; L + l <= n * 2; ++L)
Add(ans[j][l + L], 1LL * ans[i][l] * dacb[i][j][L] % Mod);
for (int i = 1; i <= n * 2; ++i) {
int res = 0;
for (int j = 1; j <= n; ++j) Add(res, ans[j][i]);
printf("%d\n", res);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
void addto(int &a, int b) { a += b, a %= 1000000007; }
struct Edge {
int to, w;
} ed[100 * 100 + 5];
struct edge {
int u, v, k;
} e[100 * 100 + 5];
vector<int> V[100 * 100 + 5], G[100 + 5][2];
bool fff = 0;
int n, m, mp[100 + 5][100 + 5], dp[100 + 5][100 + 5][100 + 5],
res[100 + 5][100 + 5], g[100 + 5][100 + 5][100 + 5], ans[100 + 5],
last[100 + 5], ecnt = 0;
void add(int u, int v, int len, bool flag) {
int p = ++ecnt;
ed[p].to = v, ed[p].w = len;
G[u][flag].push_back(p);
if (len < 6 && fff) printf("%d %d %d %d\n", u, v, len, flag);
}
int solve(int x, int now, bool flag, int &len) {
queue<int> q;
int u;
if (!flag) {
u = e[x].u, len++;
for (int i = now - 1; i >= 0; i--) q.push(V[x][i]);
while (!q.empty()) {
int v = q.front();
q.pop();
if (!mp[v][u]) return -1;
int y = mp[v][u];
len++;
if (len > (n << 1 | 1)) return -1;
for (int i = e[y].k - 1; i >= 0; i--) q.push(V[y][i]);
u = v;
}
return u;
} else {
u = e[x].v, len++;
for (int i = now + 1; i < e[x].k; i++) q.push(V[x][i]);
while (!q.empty()) {
int v = q.front();
q.pop();
if (!mp[u][v]) return -1;
int y = mp[u][v];
len++;
if (len > (n << 1 | 1)) return -1;
for (int i = 0; i < e[y].k; i++) q.push(V[y][i]);
u = v;
}
return u;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].k);
mp[e[i].u][e[i].v] = i;
for (int j = 1; j <= e[i].k; j++) {
int x;
scanf("%d", &x);
V[i].push_back(x);
}
}
for (int i = 1; i <= m; i++) {
if (!e[i].k) continue;
int s, t, len = 0;
bool flag = 0;
for (int j = 1; j < e[i].k; j++)
if (V[i][j - 1] == e[i].u && V[i][j] == e[i].v) {
s = solve(i, j - 1, 0, len), t = solve(i, j, 1, len), flag = 1;
break;
}
if (V[i][0] == e[i].v) {
int l1 = 0, tmp = solve(i, 0, 1, l1);
if (tmp != -1) {
add(e[i].u, tmp, l1, 0);
}
}
if (V[i][e[i].k - 1] == e[i].u) {
int l2 = 0, tmp = solve(i, e[i].k - 1, 0, l2);
if (tmp != -1) {
add(e[i].v, tmp, l2, 1);
}
}
if (flag && s != -1 && t != -1) {
dp[s][t][len]++;
}
}
for (int len = 2; len <= (n << 1 | 1); len++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (dp[i][j][len])
for (int k = 0; k < G[j][0].size(); k++) {
int x = G[j][0][k];
if (len + ed[x].w <= (n << 1 | 1))
addto(dp[i][ed[x].to][len + ed[x].w], dp[i][j][len]);
}
for (int len = 2; len <= (n << 1 | 1); len++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (dp[i][j][len])
for (int k = 0; k < G[i][1].size(); k++) {
int x = G[i][1][k];
if (len + ed[x].w <= (n << 1 | 1))
addto(dp[ed[x].to][j][len + ed[x].w], dp[i][j][len]);
}
for (int len = 2; len <= (n << 1 | 1); len++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (dp[i][j][len])
for (int k = 1; k <= n; k++)
if (mp[k][i] && !e[mp[k][i]].k) addto(g[k][j][len], dp[i][j][len]);
for (int len = 2; len <= (n << 1 | 1); len++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (dp[i][j][len]) addto(res[j][len], dp[i][j][len]);
for (int len = 2; len <= (n << 1 | 1); len++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k + len <= (n << 1 | 1); k++)
addto(res[j][len + k], res[i][len] * 1ll * g[i][j][k] % 1000000007);
for (int len = 2; len <= (n << 1 | 1); len++)
for (int i = 1; i <= n; i++) addto(ans[len], res[i][len]);
for (int i = 1; i <= (n << 1); i++) printf("%d\n", ans[i + 1]);
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m, Tm;
long long ans[N << 1];
struct st {
int from, nxt, to, siz;
vector<int> p;
} ed[N * N];
int head[N], num;
void add(int from, int to) {
ed[++num].to = to, ed[num].from = from;
ed[num].nxt = head[from];
head[from] = num;
}
vector<int> E, A, S[2];
int tot_len;
bool fg;
int dfs(int x, int typ, int dep) {
if (!fg) S[typ].push_back(x);
if (E.size() == A.size()) {
tot_len += dep;
return x;
}
if (dep == 2 * n) return 0;
for (int u, i = head[x]; i; i = ed[i].nxt) {
u = ed[i].to;
if (((i & 1) != typ) || (u != E[A.size()])) continue;
A.push_back(u);
for (auto v : ed[i].p) E.push_back(v);
return dfs(u, typ, dep + 1);
}
return 0;
}
int dp[N][N][N << 1][2], f[N][N << 1][2];
const int mod = 1e9 + 7;
void MD(int &x) { x = (x >= mod) ? x - mod : x; }
struct St {
int nxt, to, dis, typ;
} Ed[N * N];
int Head[N], Num;
void Add(int from, int to, int dis, int typ) {
if (!from || !to) return;
swap(from, to);
Ed[++Num].to = to, Ed[Num].dis = dis, Ed[Num].typ = typ;
Ed[Num].nxt = Head[from];
Head[from] = Num;
}
vector<int> V0[N];
int main() {
fg = 1;
int u, v, k;
scanf("%d%d", &n, &m);
for (int x, i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &k), add(u, v);
if (!k) V0[v].push_back(u);
while (k--) scanf("%d", &x), ed[num].p.push_back(x);
add(v, u);
ed[num].siz = ed[num - 1].siz = ed[num - 1].p.size();
for (int j = ed[num - 1].siz - 1; j >= 0; j--)
ed[num].p.push_back(ed[num - 1].p[j]);
}
for (int i = 1; i <= 2 * m; i += 2) {
int flg = -1;
for (int j = 0; j < ed[i].siz - 1; j++)
if (ed[i].p[j] == ed[i].from && ed[i].p[j + 1] == ed[i].to) {
flg = j;
break;
}
if (!(~flg)) continue;
E.clear(), A.clear(), S[0].clear(), S[1].clear(), tot_len = 1;
for (int j = flg - 1; j >= 0; j--) E.push_back(ed[i].p[j]);
int L = dfs(ed[i].from, 0, 0);
E.clear(), A.clear();
for (int j = flg + 2; j < ed[i].siz; j++) E.push_back(ed[i].p[j]);
int R = dfs(ed[i].to, 1, 0);
if (L && R && tot_len <= 2 * n) {
if (!fg) {
printf("%d\n", S[0].size() + S[1].size()),
fg = 1, reverse(S[0].begin(), S[0].end());
for (auto u : S[0]) printf("%d ", u);
for (auto u : S[1]) printf("%d ", u);
putchar(10);
}
Add(L, R, tot_len, 2);
}
}
if (!fg) printf("0\n\n"), fg = 1;
for (int x, i = 1; i <= 2 * m; i += 2)
if (ed[i].p.size() && ed[i].p[0] == ed[i].to) {
A.clear(), E.clear();
for (int j = 1; j < ed[i].siz; j++) E.push_back(ed[i].p[j]);
tot_len = 0, x = dfs(ed[i].to, 1, 1), Add(ed[i].from, x, tot_len, 1);
}
for (int x, i = 2; i <= 2 * m; i += 2)
if (ed[i].p.size() && ed[i].p[0] == ed[i].to) {
A.clear(), E.clear();
for (int j = 1; j < ed[i].siz; j++) E.push_back(ed[i].p[j]);
tot_len = 0, x = dfs(ed[i].to, 0, 1), Add(x, ed[i].from, tot_len, 0);
}
for (int i = 1; i <= n; i++) dp[i][i][0][0] = 1;
for (int len = 1; len <= 2 * n; len++)
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++)
for (int i = Head[y]; i; i = Ed[i].nxt) {
if (len < Ed[i].dis) continue;
if (Ed[i].typ == 2)
dp[x][y][len][1] += dp[x][Ed[i].to][len - Ed[i].dis][0];
else if (!Ed[i].typ)
dp[x][y][len][0] += dp[x][Ed[i].to][len - Ed[i].dis][0];
else
dp[x][y][len][1] += dp[x][Ed[i].to][len - Ed[i].dis][1];
MD(dp[x][y][len][0]), MD(dp[x][y][len][1]);
}
for (int i = 1; i <= n; i++) f[i][0][0] = 1;
for (int len = 1; len <= 2 * n; len++)
for (int y = 1; y <= n; y++) {
for (auto u : V0[y]) f[y][len][0] += f[u][len - 1][1], MD(f[y][len][0]);
for (int u = 1; u <= n; u++)
for (int k = 1; k <= len; k++)
f[y][len][1] += (long long)f[u][len - k][0] * dp[u][y][k][1] % mod,
MD(f[y][len][1]);
}
for (int len = 1; len <= 2 * n; len++) {
for (int i = 1; i <= n; i++) f[0][len][1] += f[i][len][1], MD(f[0][len][1]);
printf("%d\n", f[0][len][1]);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 110;
const int M = N * N;
int n, m;
vector<int> lst[M];
int op[M], ed[M];
int G[N][N];
int g[2][2][N][N][N], f[N][N][2];
int a[N][N][N], b[N][N][N];
inline pair<int, int> calc(vector<int> &tp, int x, bool flg) {
for (int i = 0; i < tp.size(); i++) {
int y = tp[i], t = G[x][y];
if (!t || tp.size() > 2 * n || (t > m) != flg)
return pair<int, int>(0xdeaded, -1);
for (auto j : lst[t]) tp.push_back(j);
x = y;
}
return pair<int, int>(tp.size(), x);
}
inline void solve(bool flg) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
int lb = !flg ? 1 : m + 1, rb = !flg ? m : 2 * m;
for (int i = lb; i <= rb; i++)
for (auto p = lst[i].begin(); p != lst[i].end(); p++)
if (*p == op[i]) {
vector<int> t1(lst[i].begin(), p);
reverse(t1.begin(), t1.end());
pair<int, int> rs = calc(t1, op[i], !flg);
if (rs.first > 2 * n) continue;
if (p + 1 == lst[i].end())
b[rs.second][ed[i]][rs.first + 1]++;
else {
if (*(p + 1) != ed[i]) continue;
vector<int> t2(p + 2, lst[i].end());
pair<int, int> rs2 = calc(t2, ed[i], flg);
if (rs.first + rs2.first + 1 <= 2 * n)
a[rs.second][rs2.second][rs.first + rs2.first + 1]++;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &op[i], &ed[i]);
G[op[i]][ed[i]] = i;
op[i + m] = ed[i];
ed[i + m] = op[i];
G[op[i + m]][ed[i + m]] = i + m;
int k;
scanf("%d", &k);
for (int j = 1, u; j <= k; j++) scanf("%d", &u), lst[i].push_back(u);
lst[i + m] = lst[i];
reverse(lst[i + m].begin(), lst[i + m].end());
if (!k) g[0][0][op[i]][ed[i]][1]++;
}
solve(0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= 2 * n; k++)
g[1][0][i][j][k] = b[i][j][k], g[1][1][i][j][k] = a[i][j][k];
solve(1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= 2 * n; k++) g[0][1][j][i][k] = b[i][j][k];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= 2 * n; k++)
for (int l = 0; l < 2; l++) (f[k][j][l] += g[1][l][i][j][k]) %= MOD;
for (int k = 1; k <= 2 * n; k++) {
int rs = 0;
for (int i = 1; i <= n; i++) {
(rs += f[k][i][1]) %= MOD;
for (int l = 0; l < 2; l++)
if (f[k][i][l])
for (int p = 0; p < 2; p++)
for (int j = 1; j <= n; j++)
for (int len = 1; len <= 2 * n - k; len++)
(f[k + len][j][p] +=
1ll * f[k][i][l] * g[l ^ 1][p][i][j][len] % MOD) %= MOD;
}
printf("%d\n", rs);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, D = 100010;
const int mod = 1e9 + 7;
int n, m, e[N][N], rv, rl, id[2][N][N], dn, ans[N];
int sv[D], svt, de[D], dp[D];
vector<int> tp[D], dv[N][N];
void inc(int &a, int b) {
if (a += b, a >= mod) a -= mod;
}
void go(int u, int ty) {
rv = -1, rl = 0;
while (rl + 1 <= svt && rl <= 2 * n) {
int v = sv[++rl];
if (e[u][v] != ty) return;
for (int j = 0, jt = dv[u][v].size(); j < jt; ++j) sv[++svt] = dv[u][v][j];
u = v;
}
rv = u;
if (rl > 2 * n) rv = -1;
}
void link(int u, int v) {
tp[u].push_back(v), ++de[v];
if (v == 56) v = 56;
}
void trans(int *u, int *v, int l) {
for (int i = 0; i + l <= 2 * n; ++i) link(u[i], v[i + l]);
}
void build() {
for (int u = 1; u <= n; ++u)
for (int v = 1; v <= n; ++v) {
vector<int> ls = dv[u][v];
if (e[u][v] == 1) {
for (int j = 0, jt = ls.size(); j + 1 < jt; ++j)
if (ls[j] == u && ls[j + 1] == v) {
int len = 0, uu, vv;
svt = 0;
for (int jj = j - 1; jj >= 0; --jj) sv[++svt] = ls[jj];
go(u, -1), uu = rv, len += rl;
svt = 0;
for (int jj = j + 2; jj < jt; ++jj) sv[++svt] = ls[jj];
go(v, 1), vv = rv, len += rl;
if (uu > 0 && vv > 0 && len <= 2 * n)
trans(id[1][uu], id[0][vv], len + 1);
break;
}
if (!ls.size()) {
trans(id[0][u], id[1][v], 1);
} else if (ls[0] == v) {
svt = 0;
for (int j = 1, jt = ls.size(); j < jt; ++j) sv[++svt] = ls[j];
go(v, 1);
if (rv > 0) trans(id[0][u], id[0][rv], rl + 1);
}
}
if (e[u][v] == -1 && ls.size() && ls[0] == v) {
svt = 0;
for (int j = 1, jt = ls.size(); j < jt; ++j) sv[++svt] = ls[j];
go(v, -1);
if (rv > 0) trans(id[1][rv], id[1][u], rl + 1);
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v, k, x;
scanf("%d %d %d", &u, &v, &k);
e[u][v] = 1, e[v][u] = -1;
for (int j = 0; j < k; ++j) {
scanf("%d", &x);
dv[u][v].push_back(x);
}
for (int j = 0; j < k; ++j) dv[v][u].push_back(dv[u][v][k - 1 - j]);
}
for (int i = 1; i <= n; ++i)
for (int l = 0; l <= 2 * n; ++l) {
id[1][i][l] = ++dn;
if (!l) dp[dn] = 1;
id[0][i][l] = ++dn;
}
build();
svt = 0;
for (int i = 1; i <= dn; ++i)
if (!de[i]) sv[++svt] = i;
while (svt) {
int u = sv[svt--], v;
for (int j = 0, jt = tp[u].size(); j < jt; ++j) {
v = tp[u][j];
inc(dp[v], dp[u]);
if (--de[v] == 0) sv[++svt] = v;
}
}
for (int i = 1; i <= n; ++i)
for (int l = 1; l <= 2 * n; ++l) {
inc(ans[l], dp[id[0][i][l]]);
}
for (int i = 1; i <= 2 * n; ++i) printf("%d\n", ans[i]);
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int INF = (int)1e9 + 1;
const long double EPS = 1e-9;
const int MOD = (int)1e9 + 7;
void add(int &x, int y) {
if ((x += y) >= MOD) {
x -= MOD;
}
}
int mult(int x, int y) { return (long long)x * y % MOD; }
const int maxn = 50 + 5;
int go[maxn][maxn], ids[maxn][maxn];
const int maxm = maxn * (maxn - 1) / 2;
vector<int> inside[maxm];
bool check(int rev, vector<int> &cur, int maxLen) {
for (int i = 0; i < ((int)(cur).size()) - 1 && ((int)(cur).size()) <= maxLen;
++i) {
int s = cur[i], t = cur[i + 1];
if (rev) {
swap(s, t);
}
if (!go[s][t]) {
return 0;
}
int id = ids[s][t];
for (int pos = 0;
pos < ((int)(inside[id]).size()) && ((int)(cur).size()) <= maxLen;
++pos) {
cur.push_back(
inside[id][rev ? (((int)(inside[id]).size()) - 1 - pos) : pos]);
}
}
return ((int)(cur).size()) <= maxLen;
}
const int maxl = 2 * maxn + 1;
struct Piece {
int first, last;
int len;
Piece() {}
Piece(int _first, int _last, int _len)
: first(_first), last(_last), len(_len) {}
};
int maxLen;
int d[maxl][2][maxn];
int ans[maxl];
void addVector(const vector<Piece> &pieces, int ntype, int len, int type, int v,
int value) {
for (const Piece &p : pieces) {
if (p.first != v) {
continue;
}
int nlen = len + p.len;
if (nlen > maxLen) {
continue;
}
add(d[nlen][ntype][p.last], value);
}
}
bool solve() {
int n, m;
if (scanf("%d%d", &n, &m) < 2) {
return 0;
}
assert(n <= maxn && m <= maxm);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
go[i][j] = 0, ids[i][j] = -1;
}
}
for (int i = 0; i < m; ++i) {
int s, t, k;
scanf("%d%d%d", &s, &t, &k);
--s, --t;
go[s][t] = 1;
ids[s][t] = i;
inside[i].resize(k);
for (int j = 0; j < k; ++j) {
scanf("%d", &inside[i][j]);
--inside[i][j];
}
}
maxLen = 2 * n;
vector<Piece> lefts, rights, mids, spaces;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (!go[i][j]) {
continue;
}
int id = ids[i][j];
if (((int)(inside[id]).size())) {
continue;
}
spaces.push_back(Piece(i, j, 1));
}
}
for (int rev = 0; rev < 2; ++rev) {
for (int v = 0; v < n; ++v) {
for (int t = 0; t < n; ++t) {
int a = v, b = t;
if (rev) {
swap(a, b);
}
if (go[a][b] == 0) {
continue;
}
int id = ids[a][b];
if (((int)(inside[id]).size()) > maxLen ||
((int)(inside[id]).size()) == 0) {
continue;
}
vector<int> vis = inside[id];
if (rev) {
reverse(vis.begin(), vis.end());
}
if (vis[0] != t) {
continue;
}
if (check(rev, vis, maxLen)) {
Piece toadd(v, vis[((int)(vis).size()) - 1], ((int)(vis).size()));
if (rev) {
swap(toadd.first, toadd.last);
}
(!rev ? rights : lefts).push_back(toadd);
}
}
}
}
for (int s = 0; s < n; ++s) {
for (int t = 0; t < n; ++t) {
if (!go[s][t]) {
continue;
}
int id = ids[s][t];
for (int pos = 0; pos < ((int)(inside[id]).size()) - 1; ++pos) {
if (inside[id][pos] != s || inside[id][pos + 1] != t) {
continue;
}
vector<int> cur;
for (int j = pos + 1; j < ((int)(inside[id]).size()); ++j) {
cur.push_back(inside[id][j]);
}
if (check(0, cur, maxLen - pos - 1)) {
vector<int> right = cur;
cur.clear();
for (int j = pos; j >= 0; --j) {
cur.push_back(inside[id][j]);
}
if (check(1, cur, maxLen - ((int)(right).size()))) {
reverse(cur.begin(), cur.end());
mids.push_back(
Piece(cur[0], right[((int)(right).size()) - 1],
((int)(cur).size()) + ((int)(right).size()) - 1));
}
}
}
}
}
for (int i = 0; i <= maxLen; ++i) {
ans[i] = 0;
for (int type = 0; type < 2; ++type) {
for (int v = 0; v < n; ++v) {
d[i][type][v] = 0;
}
}
}
for (int v = 0; v < n; ++v) {
d[0][0][v] = 1;
}
for (int len = 0; len <= maxLen; ++len) {
for (int type = 0; type < 2; ++type) {
for (int v = 0; v < n; ++v) {
int &cur = d[len][type][v];
if (cur == 0) {
continue;
}
if (type == 1) {
add(ans[len], cur);
}
if (type == 0) {
addVector(lefts, 0, len, type, v, cur);
addVector(mids, 1, len, type, v, cur);
}
if (type == 1) {
addVector(rights, 1, len, type, v, cur);
addVector(spaces, 0, len, type, v, cur);
}
}
}
}
for (int i = 1; i <= maxLen; ++i) {
printf("%d\n", ans[i]);
}
return 1;
}
int main() {
srand(rdtsc());
while (1) {
if (!solve()) break;
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e9 + 7;
const int N = 55;
int f[2][2 * N][N];
int g[2][2][2 * N][N][N];
int e[N][N], st[N * N], ed[N * N], n, m;
int v1[2 * N][N][N], v2[2 * N][N][N];
vector<int> seq[N * N];
pair<int, int> walk(vector<int> &vec, int x, int flg) {
int p = 0;
for (; p + 1 <= vec.size();) {
int y = vec[p], ed = e[x][y];
if (!ed || vec.size() > 2 * n || ((ed > m) ^ flg))
return pair<int, int>(23333, -1);
for (auto j : seq[ed]) vec.push_back(j);
x = y;
++p;
}
return pair<int, int>(vec.size(), x);
}
void work(bool flg) {
memset(v1, 0, sizeof(v1));
memset(v2, 0, sizeof(v2));
for (int i = (int)(1); i <= (int)(2 * m); i++)
if ((i <= m) ^ flg)
for (int j = (int)(0); j <= (int)(seq[i].size() - 1); j++)
if (seq[i][j] == st[i]) {
int sz = seq[i].size();
vector<int> t1, t2;
for (int k = (int)(j - 1); k >= (int)(0); k--)
t1.push_back(seq[i][k]);
pair<int, int> res1 = walk(t1, st[i], flg ^ 1);
if (res1.first > 2 * n) continue;
if (j + 1 == sz)
++v2[res1.first + 1][res1.second][ed[i]];
else if (seq[i][j + 1] == ed[i]) {
for (int k = (int)(j + 2); k <= (int)(sz - 1); k++)
t2.push_back(seq[i][k]);
pair<int, int> res2 = walk(t2, ed[i], flg);
if (res2.first + res1.first + 1 <= 2 * n)
++v1[res1.first + res2.first + 1][res1.second][res2.second];
}
}
}
void UPD(int &x, int y) { (x += y) >= mo ? x -= mo : 233; }
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(m); i++) {
int x, y, cnt, v;
scanf("%d%d%d", &x, &y, &cnt);
e[x][y] = i;
e[y][x] = i + m;
st[i] = ed[i + m] = x;
ed[i] = st[i + m] = y;
for (int j = (int)(1); j <= (int)(cnt); j++) {
scanf("%d", &v);
seq[i].push_back(v);
}
seq[i + m] = seq[i];
reverse(seq[i + m].begin(), seq[i + m].end());
if (!cnt) ++g[0][0][1][x][y];
}
work(0);
memcpy(g[1][1], v1, sizeof(v1));
memcpy(g[1][0], v2, sizeof(v2));
work(1);
for (int l = (int)(1); l <= (int)(n * 2); l++)
for (int x = (int)(1); x <= (int)(n); x++)
for (int y = (int)(1); y <= (int)(n); y++) g[0][1][l][x][y] = v2[l][y][x];
for (int l = (int)(1); l <= (int)(n * 2); l++)
for (int x = (int)(1); x <= (int)(n); x++)
for (int y = (int)(1); y <= (int)(n); y++)
for (int fl = (int)(0); fl <= (int)(1); fl++)
UPD(f[fl][l][y], g[1][fl][l][x][y]);
for (int l = (int)(1); l <= (int)(n * 2); l++) {
int ans = 0;
for (int i = (int)(1); i <= (int)(n); i++) {
UPD(ans, f[1][l][i]);
for (int la = (int)(0); la <= (int)(1); la++)
for (int no = (int)(0); no <= (int)(1); no++)
for (int j = (int)(0); j <= (int)(2 * n - l); j++)
for (int k = (int)(1); k <= (int)(n); k++)
UPD(f[no][l + j][k],
1ll * f[la][l][i] * g[la ^ 1][no][j][i][k] % mo);
}
printf("%d\n", ans);
}
}
| 11 |
CPP
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.