text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int first = 0;
cerr << '{';
for (auto &i : x) cerr << (first++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void test_case() {
int a;
cin >> a;
vector<vector<vector<int>>> in(a, vector<vector<int>>(3));
for (int i = 0; i < a; i++) {
int d;
cin >> d;
for (int j = 0; j < d; j++) {
int x, y;
cin >> x >> y, x--;
in[i][x].push_back(y);
}
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < 3; j++) {
if (in[i][j].empty()) continue;
sort(in[i][j].rbegin(), in[i][j].rend());
if (j == 0) {
while (in[i][j].size() > 3) in[i][j].pop_back();
} else {
while (in[i][j].size() > 1) in[i][j].pop_back();
}
}
}
vector<vector<long long>> dp(a + 1, vector<long long>(10, -1e18));
dp[0][0] = 0;
for (int i = 0; i < a; i++) {
vector<vector<long long>> dp2(4, vector<long long>(2, -1e18));
dp2[0][0] = 0;
vector<pair<long long, int>> can;
for (int j = 0; j < 3; j++) {
for (auto &x : in[i][j]) {
can.push_back({x, j + 1});
}
}
sort(can.begin(), can.end());
do {
int cards = 0, used = 0;
long long mx = 0, sum = 0;
for (int j = 0; j < (int)can.size(); j++) {
cards++, used += can[j].second, mx = max(mx, can[j].first),
sum += can[j].first;
if (used > 3) break;
dp2[cards][0] = max(dp2[cards][0], sum);
dp2[cards][1] = max(dp2[cards][1], sum + mx);
}
} while (next_permutation(can.begin(), can.end()));
for (int j = 0; j < 10; j++) {
for (int k = 0; k < 4; k++) {
int first = j + k >= 10;
dp[i + 1][(j + k) % 10] =
max(dp[i + 1][(j + k) % 10], dp[i][j] + dp2[k][first]);
}
}
}
cout << *max_element(dp[a].begin(), dp[a].end());
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
test_case();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 200005;
int n, len[Maxn];
long long ans;
vector<long long> a[Maxn][4];
long long dp[Maxn][10], f[4][2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", len + i);
for (int j = 0; j < len[i]; ++j) {
int x;
long long y;
scanf("%d %lld", &x, &y);
a[i][x].push_back(y);
}
for (int j = 1; j < 4; ++j) {
sort(a[i][j].rbegin(), a[i][j].rend());
while ((int)a[i][j].size() * j > 3) a[i][j].pop_back();
}
}
memset(dp, -63, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
memset(f, -63, sizeof(f));
f[0][0] = 0;
vector<pair<int, long long> > b;
for (int j = 1; j < 4; ++j)
for (auto &x : a[i][j]) b.push_back({j, x});
sort(b.begin(), b.end());
do {
int cost = 0, cnt = 0;
long long mx = 0, now = 0;
for (auto &[t, c] : b) {
cnt++, cost += t;
if (cost > 3) break;
mx = max(mx, c), now += c;
f[cnt][0] = max(f[cnt][0], now);
f[cnt][1] = max(f[cnt][1], now + mx);
}
} while (next_permutation(b.begin(), b.end()));
for (int j = 0; j < 10; ++j)
for (int k = 0; k <= 3; ++k) {
bool flag = j + k >= 10;
long long now = dp[i - 1][j] + f[k][flag];
dp[i][(j + k) % 10] = max(dp[i][(j + k) % 10], now);
}
}
for (int i = n; ~i; --i)
for (int j = 9; ~j; --j) ans = max(ans, dp[i][j]);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long dp[N][10];
bool cmp(int a, int b) { return a >= b; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j < 10; ++j) {
dp[i][j] = -1;
}
}
dp[0][0] = 0;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int k;
cin >> k;
vector<int> v[4];
for (int j = 1; j <= k; ++j) {
int c, d;
cin >> c >> d;
if (c <= 3) v[c].push_back(d);
}
for (int i = 1; i <= 3; ++i) sort(v[i].begin(), v[i].end(), cmp);
vector<pair<int, pair<long long, int> > > lst;
lst.push_back(make_pair(0, make_pair(0, 0)));
for (int i = 1; i <= 3; ++i) {
if (v[i].size() >= 1)
lst.push_back(make_pair(1, make_pair(v[i][0], v[i][0])));
}
if (v[1].size() >= 2)
lst.push_back(make_pair(2, make_pair(v[1][0] + v[1][1], v[1][0])));
if (v[1].size() >= 1 && v[2].size() >= 1)
lst.push_back(
make_pair(2, make_pair(v[1][0] + v[2][0], max(v[1][0], v[2][0]))));
if (v[1].size() >= 3)
lst.push_back(make_pair(
3, make_pair((long long)v[1][0] + v[1][1] + v[1][2], v[1][0])));
for (int j = 0; j < lst.size(); ++j) {
for (int k = 0; k < 10; ++k) {
if (dp[i - 1][k] == -1) continue;
int nx = k + lst[j].first;
long long dmg = lst[j].second.first;
if (nx >= 10) dmg += lst[j].second.second;
nx %= 10;
dp[i][nx] = max(dp[i][nx], dp[i - 1][k] + dmg);
ans = max(ans, dp[i][nx]);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ii = pair<int, ll>;
using li = pair<ll, int>;
using vi = vector<ll>;
using vii = vector<ii>;
using graph = vector<vi>;
const ll MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 312345;
const double PI = 3.14159265359;
const double EPS = 0.000000001;
ll cost[8][MAXN];
ll dp[15][MAXN];
vi o, t, s;
void process(int j) {
for (int i = 1; i <= 6; ++i) {
cost[i][j] = 0;
}
sort(o.begin(), o.end());
sort(t.begin(), t.end());
sort(s.begin(), s.end());
if (o.size() >= 1) {
cost[1][j] = -o[0];
cost[4][j] = cost[1][j] << 1;
}
if (o.size() >= 2) {
cost[2][j] = -(o[0] + o[1]);
cost[5][j] = cost[2][j] - o[0];
}
if (o.size() >= 3) {
for (int i = 0; i < 3; ++i) {
cost[3][j] += -o[i];
}
cost[6][j] = cost[3][j] - o[0];
}
if (t.size() >= 1) {
cost[1][j] = max(cost[1][j], -t[0]);
cost[4][j] = cost[1][j] << 1;
if (o.size() >= 1) {
cost[2][j] = max(cost[2][j], -(o[0] + t[0]));
cost[5][j] = max(cost[5][j], -(o[0] + t[0] + min(o[0], t[0])));
}
}
if (s.size() >= 1) {
cost[1][j] = max(cost[1][j], -s[0]);
cost[4][j] = cost[1][j] << 1;
}
}
int n;
ll sol(int i, int r) {
if (i > n) return 0;
if (dp[r][i]) return dp[r][i];
ll ans = 0;
ans = sol(i + 1, r);
for (int j = 1; j <= 3; ++j) {
if (r >= 10 - j && cost[3 + j][i]) {
ans = max(ans, cost[3 + j][i] + sol(i + 1, (r + j) % 10));
} else if (cost[j][i]) {
ans = max(ans, cost[j][i] + sol(i + 1, (r + j) % 10));
}
}
return dp[r][i] = ans;
}
int main() {
scanf("%d", &n);
for (int j = 1, q, a, b; j <= n; ++j) {
scanf("%d", &q);
o.clear();
t.clear();
s.clear();
while (q--) {
scanf("%d %d", &a, &b);
if (a == 1) {
o.push_back(-b);
} else if (a == 2) {
t.push_back(-b);
} else {
s.push_back(-b);
}
}
process(j);
}
printf("%lld\n", sol(1, 0));
}
|
#include <bits/stdc++.h>
const long long md = 1e9 + 7;
const long long Inf = 1e9;
const long long Inf64 = 1e18;
const long long MaxN = 1e5 + 100;
const long long LogN = 20;
const long long MaxM = 5e5 + 10;
const double eps = 1e-3;
const int dx[8] = {1, -1, 2, 2, -1, 1, -2, -2};
const int dy[8] = {2, 2, 1, -1, -2, -2, 1, -1};
const int ddx[4] = {1, 1, -1, -1};
const int ddy[4] = {1, -1, 1, -1};
const double Pi = acos(-1);
using namespace std;
template <typename T>
istream &operator>>(istream &in, pair<T, T> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, pair<T, T> a) {
out << a.first << ' ' << a.second;
return out;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &Mt) {
for (T &a : Mt) in >> a;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> Mt) {
for (int i = 0; i < (int)Mt.size(); i++) {
out << Mt[i];
if (i != (int)Mt.size()) out << ' ';
}
out << '\n';
return out;
}
inline long long Mod(long long &a, long long m = md) {
while (a >= m) a -= m;
return a;
}
inline long long gcd(long long a, long long b) {
while (a) {
b %= a;
swap(a, b);
}
return b;
}
inline long long gcdex(long long a, long long mod = md) {
long long g = mod, r = a, x = 0, y = 1;
while (r != 0) {
long long q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + mod : x;
}
inline long long binpow(long long a, long long n, long long m = md) {
long long res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= m;
}
a *= a;
a %= m;
n >>= 1;
}
return res % md;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{
long long N, a, b, x, t, c, d, dmax, id;
cin >> N;
vector<vector<tuple<long long, long long, long long>>> Mt(N + 1);
for (int i = 1; i <= N; i++) {
cin >> x;
vector<vector<long long>> Kt(4);
for (int j = 0; j < x; j++) {
cin >> c >> d;
Kt[c].push_back(d);
}
for (int j = 1; j <= 3; j++) sort(Kt[j].rbegin(), Kt[j].rend());
Mt[i].push_back({0, 0, 0});
if (Kt[1].size() > 0) Mt[i].push_back({1, Kt[1][0], Kt[1][0]});
if (Kt[2].size() > 0) Mt[i].push_back({1, Kt[2][0], Kt[2][0]});
if (Kt[3].size() > 0) Mt[i].push_back({1, Kt[3][0], Kt[3][0]});
if ((Kt[1].size() > 0) && (Kt[2].size() > 0))
Mt[i].push_back({2, Kt[1][0] + Kt[2][0], max(Kt[1][0], Kt[2][0])});
if (Kt[1].size() > 1)
Mt[i].push_back({2, Kt[1][0] + Kt[1][1], max(Kt[1][0], Kt[1][1])});
if (Kt[1].size() > 2)
Mt[i].push_back({3, Kt[1][0] + Kt[1][1] + Kt[1][2],
max(Kt[1][0], max(Kt[1][1], Kt[1][2]))});
}
vector<vector<long long>> dp(N + 1, vector<long long>(10, -Inf64));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 10; j++) {
for (auto p : Mt[i + 1]) {
tie(c, d, dmax) = p;
x = dp[i][j] + d;
if (j + c >= 10) x += dmax;
id = (j + c) % 10;
dp[i + 1][id] = max(dp[i + 1][id], x);
}
}
}
long long Ans = 0;
for (int i = 0; i < 10; i++) Ans = max(Ans, dp[N][i]);
cout << Ans << "\n";
}
END:
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
long long n, jad[10][200005], k, x, y, ma1, ma2, ma3, vas;
vector<long long> v[4];
bool boo(long long es, long long vi) { return es > vi; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n;
for (int j = 0; j <= n; j++)
for (int i = 0; i < 10; i++) jad[i][j] = -1e18;
jad[0][0] = 0;
for (int o = 1; o <= n; o++) {
cin >> k;
for (int i = 1; i <= 3; i++) v[i].resize(0);
for (int i = 0; i < k; i++) {
cin >> x >> y;
v[x].push_back(y);
}
for (int i = 1; i <= 3; i++)
if (v[i].size()) sort(v[i].begin(), v[i].end(), boo);
ma1 = 0;
ma2 = 0;
ma3 = 0;
for (int j = 1; j <= 3; j++)
if (v[j].size()) ma1 = max(ma1, v[j][0]);
if (v[2].size() && v[1].size()) {
ma2 = max(v[2][0], v[1][0]);
if (v[2][0] == ma2)
ma3 = v[1][0];
else {
if (v[1].size() > 1)
ma3 = max(v[2][0], v[1][1]);
else
ma3 = v[2][0];
}
} else if (v[1].size() > 1) {
ma2 = v[1][0];
ma3 = v[1][1];
}
for (int i = 0; i < 10; i++) {
jad[i][o] = max(jad[i][o], jad[i][o - 1]);
if (i == 9)
jad[0][o] = max(jad[0][o], jad[i][o - 1] + ma1 * 2);
else
jad[i + 1][o] = max(jad[i + 1][o], jad[i][o - 1] + ma1);
if (ma3)
if (i >= 8)
jad[(i + 2) % 10][o] =
max(jad[(i + 2) % 10][o], jad[i][o - 1] + ma2 * 2 + ma3);
else
jad[i + 2][o] = max(jad[i + 2][o], jad[i][o - 1] + ma2 + ma3);
if (v[1].size() > 2)
if (i >= 7)
jad[(i + 3) % 10][o] =
max(jad[(i + 3) % 10][o],
jad[i][o - 1] + v[1][0] * 2 + v[1][1] + v[1][2]);
else
jad[i + 3][o] =
max(jad[i + 3][o], jad[i][o - 1] + v[1][0] + v[1][1] + v[1][2]);
}
}
for (int i = 0; i < 10; i++) vas = max(vas, jad[i][n]);
cout << vas;
}
|
#include <bits/stdc++.h>
using namespace std;
set<long long int> s[100005];
long long int d[100005];
vector<char> prime(100000 + 1, true);
void sieve(long long int n) {
prime[0] = prime[1] = false;
for (long long int i = 2; i <= n; ++i) {
if (prime[i]) {
s[i].insert(i);
for (long long int j = 2 * i; j <= n; j += i) {
prime[j] = false;
s[j].insert(i);
}
}
}
}
void init(long long int ar[], long long int n, long long int val) {
long long int i;
for (i = 0; i < n; i++) {
ar[i] = val;
}
}
long long int search1(vector<long long int> &v, long long int f) {
long long int left = 0;
long long int right = v.size() - 1;
while (left < right) {
long long int mid = left + (right - left + 1) / 2;
if (v[mid] <= f) {
left = mid;
} else
right = mid - 1;
}
return left;
}
int main() {
long long int n, k, i, j;
cin >> n;
long long int dp[n + 1][10];
for (i = 0; i <= n; i++) {
for (j = 0; j < 10; j++) {
dp[i][j] = -1000000000000000;
}
}
dp[0][0] = 0;
long long int t = n;
for (i = 1; i <= n; i++) {
cin >> k;
long long int c1, d;
long long int a1 = 0, a2 = 0, a3 = 0, b = 0, c = 0;
for (j = 0; j < k; j++) {
cin >> c1 >> d;
if (c1 == 2) {
b = max(b, d);
} else if (c1 == 3) {
c = max(c, d);
} else {
if (d >= a1) {
a3 = a2;
a2 = a1;
a1 = d;
} else if (d >= a2) {
a3 = a2;
a2 = d;
} else if (d >= a3) {
a3 = d;
}
}
}
long long int maxs = max(a1, b);
long long int mins = min(a1, b);
if (i == 1) {
dp[1][0] = 0;
if (c != 0) {
dp[1][1] = max(c, dp[1][1]);
}
if (a1 != 0) {
dp[1][1] = max(dp[1][1], a1);
}
if (b != 0) {
dp[1][1] = max(dp[1][1], b);
}
if (a1 != 0 && b != 0) {
dp[1][2] = max(dp[1][2], maxs + mins);
}
if (a2 != 0) {
dp[1][2] = max(a1 + a2, dp[1][2]);
}
if (a3 != 0) {
dp[1][3] = a1 + a2 + a3;
}
continue;
}
for (j = 0; j < 10; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
long long int val = c;
if (j == 0) val += c;
if (c != 0) dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
if (a3 != 0) {
val = a1 + a2 + a3;
if (j < 3) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 3 + 10) % 10]);
}
if (a2 != 0) {
val = a1 + a2;
if (j < 2) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 2 + 10) % 10]);
}
if (a1 != 0) {
val = a1;
if (j < 1) val += a1;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
}
if (b != 0) {
val = b;
if (j < 1) val += b;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 1 + 10) % 10]);
}
if (maxs != 0 && mins != 0) {
val = maxs + mins;
if (j < 2) val += maxs;
dp[i][j] = max(dp[i][j], val + dp[i - 1][(j - 2 + 10) % 10]);
}
}
}
cout << *max_element(dp[n], dp[n] + 10) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long q, dp[200005][15], a[555555][5], b[555555], k, l, m, n, o, p;
map<long long, long long> mp;
vector<long long> v[555555];
const long long mod = 1e9 + 7;
long long mem(long long i, long long md) {
if (i == n + 1) return 0;
long long &r = dp[i][md];
if (r != -1) return r;
long long s = min(3LL, (long long)v[i].size());
r = mem(i + 1, md);
long long sum = 0, u = 0;
for (long long j = 0; j < s; j++) {
sum += v[i][j];
if (md + j + 1 >= 10) u = max(u, v[i][0]);
r = max(r, mem(i + 1, (md + j + 1) % 10) + sum + u);
}
if (a[i][2]) {
long long sum = 0, u = 0;
if (md + 1 == 10) u = a[i][2];
sum += a[i][2];
r = max(r, mem(i + 1, (md + 1) % 10) + sum + u);
if (s) {
if (md + 2 >= 10) u = max(a[i][2], v[i][0]);
sum += v[i][0];
r = max(r, mem(i + 1, (md + 2) % 10) + sum + u);
}
}
if (a[i][3]) {
long long sum = 0, u = 0;
if (md + 1 == 10) u = a[i][3];
sum += a[i][3];
r = max(r, mem(i + 1, (md + 1) % 10) + sum + u);
}
return r;
}
void solve() {
memset(dp, -1, sizeof dp);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> b[i];
for (long long j = 0; j < b[i]; j++) {
cin >> o >> p;
if (o > 1)
a[i][o] = max(a[i][o], p);
else
v[i].push_back(p);
}
sort(v[i].begin(), v[i].end(), greater<long long>());
}
cout << mem(1, 0) << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
q = 1;
while (q--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
bool isPrime(long long a) {
long long i;
for (i = 2; i * i <= a; i++) {
if (a % i == 0) {
return 0;
}
}
return (a != 1);
}
bool isPalindrom(const string& s, int l, int r) {
for (int i = 0; i < (r - l + 1) / 2; i++) {
if (s[l + i] != s[r - i]) {
return 0;
}
}
return 1;
}
template <class type1>
type1 gcd(type1 a, type1 b) {
type1 t;
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
long long positiveMod(long long v, long long md) {
v = v % md;
if (v < 0) {
v += md;
}
return v;
}
long long dp[200005][10];
vector<long long> v1, v2, v3;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long res = 0, n, m, i, j, a, b, c;
cin >> n;
for (auto& it : dp) {
for (auto& itt : it) {
itt = -(1000000000000000007ll);
}
}
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
v1.clear();
v2.clear();
v3.clear();
cin >> m;
for (j = 0; j < m; j++) {
cin >> a >> b;
if (a == 1) {
v1.push_back(b);
}
if (a == 2) {
v2.push_back(b);
}
if (a == 3) {
v3.push_back(b);
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
sort(v3.begin(), v3.end());
reverse(v1.begin(), v1.end());
reverse(v2.begin(), v2.end());
reverse(v3.begin(), v3.end());
for (j = 0; j < 10; j++) {
dp[i][j] = dp[i - 1][j];
}
for (j = 0; j < 10; j++) {
if (!v1.empty()) {
if (j < 9) {
dp[i][j + 1] = max(dp[i][j + 1], dp[i - 1][j] + v1[0]);
} else {
dp[i][0] = max(dp[i][0], dp[i - 1][9] + v1[0] * 2);
}
}
if (!v2.empty()) {
if (j < 9) {
dp[i][j + 1] = max(dp[i][j + 1], dp[i - 1][j] + v2[0]);
} else {
dp[i][0] = max(dp[i][0], dp[i - 1][9] + v2[0] * 2);
}
}
if (!v3.empty()) {
if (j < 9) {
dp[i][j + 1] = max(dp[i][j + 1], dp[i - 1][j] + v3[0]);
} else {
dp[i][0] = max(dp[i][0], dp[i - 1][9] + v3[0] * 2);
}
}
if ((!v2.empty()) && (!v1.empty())) {
if (j < 8) {
dp[i][j + 2] = max(dp[i][j + 2], dp[i - 1][j] + v1[0] + v2[0]);
} else {
dp[i][j + 2 - 10] =
max(dp[i][j + 2 - 10],
dp[i - 1][j] + max(v1[0], v2[0]) * 2 + min(v1[0], v2[0]));
}
}
if (v1.size() >= 2) {
if (j < 8) {
dp[i][j + 2] = max(dp[i][j + 2], dp[i - 1][j] + v1[0] + v1[1]);
} else {
dp[i][j + 2 - 10] =
max(dp[i][j + 2 - 10], dp[i - 1][j] + v1[0] * 2 + v1[1]);
}
}
if (v1.size() >= 3) {
if (j < 7) {
dp[i][j + 3] =
max(dp[i][j + 3], dp[i - 1][j] + v1[0] + v1[1] + v1[2]);
} else {
dp[i][j + 3 - 10] =
max(dp[i][j + 3 - 10], dp[i - 1][j] + v1[0] * 2 + v1[1] + v1[2]);
}
}
}
}
for (auto it : dp[n]) {
res = max(res, it);
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void ckmx(T &a, T b) {
if (b > a) a = b;
}
const int N = 200010;
const int Mod = 998244353;
int n, a[N];
long long b[N];
long long A[N][4][4];
long long g[N][4][4][2];
long long MX[N][4][4];
long long f[N][10];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long ans = 0;
int T;
cin >> T;
for (int ti = (1); ti <= (T); ++ti) {
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> a[i] >> b[i];
auto cal = [&](long long A[4][4]) {
for (int i = (0); i <= (3); ++i)
for (int j = (0); j <= (3); ++j) A[i][j] = -1;
A[0][0] = 0;
for (int i = (1); i <= (n); ++i)
for (int j = (3); j >= (1); --j)
for (int k = (3); k >= (a[i]); --k)
if (A[j - 1][k - a[i]] != -1) {
ckmx(A[j][k], A[j - 1][k - a[i]] + b[i]);
}
};
cal(A[ti]);
auto cal2 = [&](long long A[4][4]) {
for (int i = (0); i <= (3); ++i)
for (int j = (0); j <= (3); ++j) A[i][j] = -1;
for (int i = (0); i <= (n); ++i)
for (int j = (0); j <= (3); ++j)
for (int k = (0); k <= (3); ++k) g[i][j][k][0] = g[i][j][k][1] = -1;
g[0][0][0][1] = 0;
g[0][0][0][0] = 0;
for (int i = (1); i <= (n); ++i) {
for (int j = (0); j <= (3); ++j)
for (int k = (0); k <= (3); ++k) {
g[i][j][k][0] = g[i - 1][j][k][0];
g[i][j][k][1] = g[i - 1][j][k][1];
if (j >= 1 && k >= a[i]) {
if (g[i - 1][j - 1][k - a[i]][0] != -1)
ckmx(g[i][j][k][0], g[i - 1][j - 1][k - a[i]][0] + b[i]);
if (g[i - 1][j - 1][k - a[i]][1] != -1)
ckmx(g[i][j][k][1], g[i - 1][j - 1][k - a[i]][1] + b[i]);
if (g[i - 1][j - 1][k - a[i]][0] != -1)
ckmx(g[i][j][k][1], g[i - 1][j - 1][k - a[i]][0] + b[i] + b[i]);
}
}
}
for (int i = (0); i <= (3); ++i)
for (int j = (0); j <= (3); ++j) A[i][j] = g[n][i][j][1];
};
cal2(MX[ti]);
}
function<int(int, int)> thz = [&](int st, int ed) -> int {
int f = 0;
for (int i = (1); i <= (10); ++i) {
if ((st + i) % 10 == 0) f = 1;
if ((st + i) % 10 == ed) {
if (f) return 1;
}
}
return 0;
};
for (int i = (0); i <= (n); ++i)
for (int j = (0); j <= (9); ++j) f[i][j] = -1;
f[0][0] = 0;
for (int i = (1); i <= (T); ++i)
for (int z = (0); z <= (9); ++z) {
f[i][z] = f[i - 1][z];
for (int j = (1); j <= (3); ++j)
for (int k = (1); k <= (3); ++k) {
if (f[i - 1][(z - j + 10) % 10] == -1) continue;
if (A[i][j][k] != -1 && !thz((z - j + 10) % 10, z))
ckmx(f[i][z], f[i - 1][(z - j + 10) % 10] + A[i][j][k]);
else if (MX[i][j][k] != -1 && thz((z - j + 10) % 10, z))
ckmx(f[i][z], f[i - 1][(z - j + 10) % 10] + MX[i][j][k]);
}
ans = max(ans, f[i][z]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long INF = 1e18;
const int M = 1e9 + 7;
const int maxn = 2e5 + 5;
long long d[maxn][10];
pair<int, int> c[maxn];
long long x[maxn][5], y[maxn][5];
int main(int argc, char const *argv[]) {
int n;
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
int k;
cin >> k;
for (int j = 0; j < k; ++j) {
cin >> c[j].second >> c[j].first;
}
sort(c, c + k);
reverse(c, c + k);
x[i][1] = c[0].first;
y[i][1] = 2 * c[0].first;
long long t = 0, ok = 1, tt = 0;
for (int j = 0; j < k; ++j) {
if (c[j].second == ok) {
t += c[j].first;
if (ok == 1) {
tt += c[j].first;
}
tt += c[j].first;
++ok;
}
if (ok > 2) {
break;
}
}
if (ok > 2) {
x[i][2] = t;
y[i][2] = tt;
}
ok = 2;
t = tt = 0;
for (int j = 0; j < k; ++j) {
if (c[j].second == ok) {
t += c[j].first;
tt += c[j].first;
if (ok == 2) {
tt += c[j].first;
}
--ok;
}
if (ok == 0) {
break;
}
}
if (ok == 0) {
x[i][2] = max(x[i][2], t);
y[i][2] = max(y[i][2], tt);
}
t = 0;
ok = 1;
for (int j = 0; j < k; ++j) {
if (c[j].second == 1) {
x[i][3] += c[j].first;
if (ok > 0) {
y[i][3] += c[j].first;
ok--;
}
y[i][3] += c[j].first;
++t;
if (t == 2) {
x[i][2] = max(x[i][2], x[i][3]);
y[i][2] = max(y[i][2], y[i][3]);
} else if (t == 3) {
break;
}
}
}
if (t < 3) x[i][3] = y[i][3] = 0;
}
memset(d, 0x9f, sizeof(d));
d[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 10; ++j) {
d[i][j] = max(d[i][j], d[i - 1][j]);
for (int k = 1; x[i][k]; ++k) {
int t = (j + k) % 10;
if (j % 10 > t) {
d[i][t] = max(d[i][t], d[i - 1][j] + y[i][k]);
} else {
d[i][t] = max(d[i][t], d[i - 1][j] + x[i][k]);
}
}
}
}
long long res = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 10; ++j) {
res = max(d[i][j], res);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct st {
long long ar[3][3];
vector<long long> ar1[3][3];
};
long long memo[200001][10];
vector<st> arr;
vector<vector<pair<long long, long long> > > v;
long long n;
long long func(int x, int cnt) {
if (x >= n) return 0;
if (x == n - 1) {
long long m = 0;
if (cnt < 7) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) m = max(m, arr[x].ar[i][j]);
}
if (cnt == 7) {
if (arr[x].ar[2][2] != 0) {
long long zz = max(max(arr[x].ar1[2][2][0], arr[x].ar1[2][2][1]),
arr[x].ar1[2][2][2]);
m = max(m, (arr[x].ar[2][2] - zz) + zz * 2);
}
} else if (cnt == 8) {
if (arr[x].ar[2][2] != 0) {
long long zz = max(max(arr[x].ar1[2][2][0], arr[x].ar1[2][2][1]),
arr[x].ar1[2][2][2]);
m = max(m, (arr[x].ar[2][2] - zz) + zz * 2);
}
if (arr[x].ar[1][1] != 0) {
long long zz = max(arr[x].ar1[1][1][0], arr[x].ar1[1][1][1]);
m = max(m, (arr[x].ar[1][1] - zz) + zz * 2);
}
if (arr[x].ar[2][1] != 0) {
long long zz = max(arr[x].ar1[2][1][0], arr[x].ar1[2][1][1]);
m = max(m, (arr[x].ar[2][1] - zz) + zz * 2);
}
} else if (cnt == 9) {
if (arr[x].ar[0][0] != 0) {
m = max(m, arr[x].ar[0][0] * 2);
}
if (arr[x].ar[1][0] != 0) {
m = max(m, arr[x].ar[1][0] * 2);
}
if (arr[x].ar[2][0] != 0) {
m = max(m, arr[x].ar[2][0] * 2);
}
if (arr[x].ar[2][2] != 0) {
long long zz = max(max(arr[x].ar1[2][2][0], arr[x].ar1[2][2][1]),
arr[x].ar1[2][2][2]);
m = max(m, (arr[x].ar[2][2] - zz) + zz * 2);
}
if (arr[x].ar[1][1] != 0) {
long long zz = max(arr[x].ar1[1][1][0], arr[x].ar1[1][1][1]);
m = max(m, (arr[x].ar[1][1] - zz) + zz * 2);
}
if (arr[x].ar[2][1] != 0) {
long long zz = max(arr[x].ar1[2][1][0], arr[x].ar1[2][1][1]);
m = max(m, (arr[x].ar[2][1] - zz) + zz * 2);
}
}
return m;
}
if (memo[x][cnt] != -1) return memo[x][cnt];
long long m = 0;
m = func(x + 1, cnt);
if (arr[x].ar[0][0] != 0) {
if (cnt == 9)
m = max(m, arr[x].ar[0][0] * 2 + func(x + 1, 0));
else
m = max(m, arr[x].ar[0][0] + func(x + 1, cnt + 1));
}
if (arr[x].ar[1][0] != 0) {
if (cnt == 9)
m = max(m, arr[x].ar[1][0] * 2 + func(x + 1, 0));
else
m = max(m, arr[x].ar[1][0] + func(x + 1, cnt + 1));
}
if (arr[x].ar[2][0] != 0) {
if (cnt == 9)
m = max(m, arr[x].ar[2][0] * 2 + func(x + 1, 0));
else
m = max(m, arr[x].ar[2][0] + func(x + 1, cnt + 1));
}
if (arr[x].ar[1][1] != 0) {
long long x1 = arr[x].ar1[1][1][0];
long long y = arr[x].ar1[1][1][1];
if (cnt == 8) {
m = max(m, x1 + 2 * y + func(x + 1, 0));
m = max(m, y + 2 * x1 + func(x + 1, 0));
} else if (cnt == 9) {
m = max(m, 2 * y + x1 + func(x + 1, 1));
m = max(m, 2 * x1 + y + func(x + 1, 1));
} else {
m = max(m, x1 + y + func(x + 1, cnt + 2));
}
}
if (arr[x].ar[2][1] != 0) {
long long x1 = arr[x].ar1[2][1][0];
long long y = arr[x].ar1[2][1][1];
if (cnt == 8) {
m = max(m, x1 + 2 * y + func(x + 1, 0));
m = max(m, y + 2 * x1 + func(x + 1, 0));
} else if (cnt == 9) {
m = max(m, 2 * y + x1 + func(x + 1, 1));
m = max(m, 2 * x1 + y + func(x + 1, 1));
} else {
m = max(m, x1 + y + func(x + 1, cnt + 2));
}
}
if (arr[x].ar[2][2] != 0) {
long long x1 = arr[x].ar1[2][2][0];
long long y = arr[x].ar1[2][2][1];
long long z = arr[x].ar1[2][2][2];
if (cnt == 7) {
m = max(m, x1 + y + 2 * z + func(x + 1, 0));
m = max(m, y + z + 2 * x1 + func(x + 1, 0));
m = max(m, x1 + z + 2 * y + func(x + 1, 0));
}
if (cnt == 8) {
m = max(m, x1 + y + 2 * z + func(x + 1, 1));
m = max(m, y + z + 2 * x1 + func(x + 1, 1));
m = max(m, x1 + z + 2 * y + func(x + 1, 1));
} else if (cnt == 9) {
m = max(m, x1 + y + 2 * z + func(x + 1, 2));
m = max(m, y + z + 2 * x1 + func(x + 1, 2));
m = max(m, x1 + z + 2 * y + func(x + 1, 2));
} else {
m = max(m, x1 + y + z + func(x + 1, cnt + 3));
}
}
memo[x][cnt] = m;
return m;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
v.resize(n);
arr.resize(n);
long long temp = 0;
for (int j = 0; j < n; j++) {
cin >> temp;
v[j].resize(temp);
priority_queue<long long> q1, q2, q3;
for (int var1 = 0; var1 < 3; var1++)
for (int var2 = 0; var2 < 3; var2++) {
arr[j].ar[var1][var2] = 0;
}
for (int i = 0; i < temp; i++) {
cin >> v[j][i].first >> v[j][i].second;
if (v[j][i].first == 1)
q1.push(v[j][i].second);
else if (v[j][i].first == 2)
q2.push(v[j][i].second);
else
q3.push(v[j][i].second);
}
if (q1.size() == 0) {
if (q2.size() != 0) {
arr[j].ar[1][0] = q2.top();
}
} else {
arr[j].ar[0][0] = q1.top();
if (q2.size() == 0) {
arr[j].ar[1][0] = 0;
if (q1.size() > 1) {
long long te = q1.top();
q1.pop();
arr[j].ar[1][1] = q1.top() + te;
arr[j].ar1[1][1].push_back(te);
arr[j].ar1[1][1].push_back(q1.top());
q1.push(te);
}
arr[j].ar[1][2] = 0;
} else {
arr[j].ar[1][0] = q2.top();
if (q1.size() > 1) {
long long te = q1.top();
q1.pop();
arr[j].ar[1][1] = q1.top() + te;
arr[j].ar1[1][1].push_back(te);
arr[j].ar1[1][1].push_back(q1.top());
q1.push(te);
}
arr[j].ar[1][2] = 0;
}
}
if (q3.size() != 0)
arr[j].ar[2][0] = q3.top();
else
arr[j].ar[2][0] = 0;
if (!q1.empty() && !q2.empty()) {
arr[j].ar[2][1] = q1.top() + q2.top();
arr[j].ar1[2][1].push_back(q1.top());
arr[j].ar1[2][1].push_back(q2.top());
} else
arr[j].ar[2][1] = 0;
if (q1.size() > 2) {
arr[j].ar[2][2] = 0;
arr[j].ar[2][2] += q1.top();
arr[j].ar1[2][2].push_back(q1.top());
q1.pop();
arr[j].ar[2][2] += q1.top();
arr[j].ar1[2][2].push_back(q1.top());
q1.pop();
arr[j].ar[2][2] += q1.top();
arr[j].ar1[2][2].push_back(q1.top());
} else {
arr[j].ar[2][2] = 0;
}
}
for (int i1 = 0; i1 < 200001; i1++)
for (int j1 = 0; j1 < 10; j1++) memo[i1][j1] = -1;
cout << func(0, 0) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long memo[10][2];
long long best[3][3];
long long sbest[3];
long long dbest[3];
int main() {
memset(memo, 128, sizeof(memo));
memo[0][0] = 0;
scanf("%d", &n);
int a = 0, b = 1;
long long c, d;
while (n--) {
scanf("%d", &k);
memset(best, 128, sizeof(best));
while (k--) {
scanf("%lld%lld", &c, &d);
c--;
for (int x = 0; x < 3; x++) {
if (best[c][x] < d) {
for (int y = 2; y > x; y--) best[c][y] = best[c][y - 1];
best[c][x] = d;
break;
}
}
}
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
if (best[x][y] == -9187201950435737472)
best[x][y] = -918720195043573747;
}
}
sbest[0] = max(best[0][0], max(best[1][0], best[2][0]));
sbest[1] = max(best[0][0] + best[0][1], best[0][0] + best[1][0]);
sbest[2] = best[0][0] + best[0][1] + best[0][2];
dbest[0] = max(best[0][0] * 2, max(best[1][0] * 2, best[2][0] * 2));
dbest[1] = max(best[0][0] * 2 + best[0][1],
best[0][0] + best[1][0] + max(best[0][0], best[1][0]));
dbest[2] = best[0][0] * 2 + best[0][1] + best[0][2];
for (int x = 0; x < 10; x++) {
if (memo[x][a] < 0) continue;
memo[x][b] = max(memo[x][b], memo[x][a]);
for (int y = 0; y < 3; y++) {
if (x + y < 9)
memo[x + y + 1][b] = max(memo[x + y + 1][b], memo[x][a] + sbest[y]);
else
memo[x + y - 9][b] = max(memo[x + y - 9][b], memo[x][a] + dbest[y]);
}
}
swap(a, b);
}
long long ans = 0;
for (int x = 0; x < 10; x++) {
ans = max(ans, memo[x][a]);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, totalC, turnIndex[200000];
long long turns[200000][2], dp[200000][10], best[200000][5];
vector<int> incl[200000];
vector<int> turnCtr, scratch;
int main() {
scanf("%d", &n);
turnCtr.assign(n, 0);
int cur = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &turnCtr[i]);
priority_queue<long long> maxVals[4];
for (int j = 0; j < turnCtr[i]; j++) {
scanf("%lld %lld", &turns[cur][0], &turns[cur][1]);
maxVals[turns[cur][0]].push(turns[cur][1]);
turnIndex[cur++] = i;
}
for (int j = 0; j < 5; j++) {
best[i][j] = 0;
}
if (maxVals[3].size() > 0) {
best[i][4] = maxVals[3].top();
}
if (maxVals[2].size() > 0) {
best[i][3] = maxVals[2].top();
}
for (int j = 0; !maxVals[1].empty() && j < 3; j++) {
best[i][j] = maxVals[1].top();
maxVals[1].pop();
}
if (i > 0) {
turnCtr[i] += turnCtr[i - 1];
}
}
totalC = turnCtr[n - 1];
for (int turn = totalC - 1; turn >= 0; turn--) {
for (int soFar = 0; soFar < 10; soFar++) {
long long &temp = dp[turn][soFar];
if (turn == n - 1) {
temp = 0;
if (best[turn][4]) {
temp = max(temp, best[turn][4] * (soFar == 0 ? 2LL : 1LL));
}
if (best[turn][3] && best[turn][0]) {
temp = max(temp,
best[turn][3] + best[turn][0] +
(soFar <= 1 ? max(best[turn][3], best[turn][0]) : 0));
}
if (best[turn][3]) {
temp = max(temp, best[turn][3] + (soFar == 0 ? best[turn][3] : 0));
}
for (int mask = 0; mask < (1 << 3); mask++) {
long long additional = 0LL;
long long tempTotal = 0LL;
int on = 0;
for (int i = 0; i < 3; i++) {
if (mask & (1 << i)) {
on++;
additional = max(additional, best[turn][i]);
tempTotal += best[turn][i];
}
}
if (soFar - on < 0) {
tempTotal += additional;
}
temp = max(temp, tempTotal);
}
} else {
temp = dp[turn + 1][soFar];
if (best[turn][4]) {
temp = max(temp, dp[turn + 1][(soFar + 9) % 10] +
best[turn][4] * (soFar == 0 ? 2LL : 1LL));
}
if (best[turn][3] && best[turn][0]) {
temp = max(temp,
dp[turn + 1][(soFar + 8) % 10] + best[turn][3] +
best[turn][0] +
(soFar <= 1 ? max(best[turn][3], best[turn][0]) : 0));
}
if (best[turn][3]) {
temp = max(temp, dp[turn + 1][(soFar + 9) % 10] + best[turn][3] +
(soFar == 0 ? best[turn][3] : 0));
}
for (int mask = 0; mask < (1 << 3); mask++) {
long long additional = 0LL;
long long tempTotal = 0LL;
int on = 0;
bool poss = true;
for (int i = 0; poss && i < 3; i++) {
if ((mask & (1 << i))) {
if (!best[turn][i]) {
poss = false;
} else {
on++;
additional = max(additional, best[turn][i]);
tempTotal += best[turn][i];
}
}
}
if (poss) {
if (soFar - on < 0) {
tempTotal += additional;
}
temp = max(temp, dp[turn + 1][(soFar + 10 - on) % 10] + tempTotal);
}
}
}
}
}
printf("%lld\n", dp[0][9]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<vector<vector<long long>>> a(n);
for (int i = 0; i < n; i++) {
int k;
cin >> k;
vector<vector<long long>> ta(3);
for (int j = 0; j < k; j++) {
int c, d;
cin >> c >> d;
c--;
ta[c].push_back(d);
}
for (int j = 0; j < 3; j++) {
sort(ta[j].begin(), ta[j].end());
reverse(ta[j].begin(), ta[j].end());
}
a[i] = ta;
}
vector<long long> dp(10, -(1LL << 60));
dp[0] = 0;
for (int i = 0; i < n; i++) {
vector<long long> ndp = dp;
for (int j = 0; j < 3; j++) {
if (a[i][j].size() == 0) continue;
long long car = a[i][j][0];
for (int h = 0; h < 9; h++) {
ndp[h + 1] = max(ndp[h + 1], dp[h] + car);
}
ndp[0] = max(ndp[0], dp[9] + car * 2);
}
if (a[i][0].size() >= 2) {
long long car0 = a[i][0][0], car1 = a[i][0][1];
for (int h = 0; h < 8; h++) {
ndp[h + 2] = max(ndp[h + 2], dp[h] + car0 + car1);
}
ndp[0] = max(ndp[0], dp[8] + car0 * 2 + car1);
ndp[1] = max(ndp[1], dp[9] + car0 * 2 + car1);
}
if (a[i][0].size() > 0 && a[i][1].size() > 0) {
long long car0 = max(a[i][0][0], a[i][1][0]),
car1 = min(a[i][0][0], a[i][1][0]);
for (int h = 0; h < 8; h++) {
ndp[h + 2] = max(ndp[h + 2], dp[h] + car0 + car1);
}
ndp[0] = max(ndp[0], dp[8] + car0 * 2 + car1);
ndp[1] = max(ndp[1], dp[9] + car0 * 2 + car1);
}
if (a[i][0].size() >= 3) {
long long car0 = a[i][0][0], car1 = a[i][0][1], car2 = a[i][0][2];
for (int h = 0; h < 7; h++) {
ndp[h + 3] = max(ndp[h + 3], dp[h] + car0 + car1 + car2);
}
ndp[0] = max(ndp[0], dp[7] + car0 * 2 + car1 + car2);
ndp[1] = max(ndp[1], dp[8] + car0 * 2 + car1 + car2);
ndp[2] = max(ndp[2], dp[9] + car0 * 2 + car1 + car2);
}
dp = ndp;
}
long long res = 0;
for (int i = 0; i < 10; i++) res = max(res, dp[i]);
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long INFll = 1ll * 1000000000 * 1000000000;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int mul(int a, int b, int mod = 1000000007) { return int(a * 1ll * b % mod); }
int norm(int a, int mod = 1000000007) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
int powmod(int x, int y, int mod = 1000000007) {
int res = 1;
while (y > 0) {
if (y & 1) res = mul(res, x, mod);
x = mul(x, x, mod);
y = y >> 1;
}
return res;
}
int inv(int a, int mod = 1000000007) { return powmod(a, mod - 2); }
long long dp[200005][11];
int main() {
fast();
int n;
cin >> n;
vector<vector<pair<long long, long long>>> mpr(
n + 1, vector<pair<long long, long long>>(4, {0, 0}));
for (int i = 0; i <= n; i++)
for (int j = 1; j <= 10; j++) dp[i][j] = (LLONG_MIN + 2 * 1000000000);
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
vector<long long> v[4];
for (int j = 0; j < k; j++) {
int c, d;
cin >> c >> d;
v[c].push_back(d);
}
for (int j = 1; j < 4; j++) sort(v[j].rbegin(), v[j].rend());
if (v[1].size() >= 1) {
mpr[i][1].first = v[1][0];
mpr[i][1].second = 2 * v[1][0];
}
if (v[2].size() >= 1) {
mpr[i][1].first = max(mpr[i][1].first, v[2][0]);
mpr[i][1].second = max(mpr[i][1].second, 2 * v[2][0]);
}
if (v[3].size() >= 1) {
mpr[i][1].first = max(mpr[i][1].first, v[3][0]);
mpr[i][1].second = max(mpr[i][1].second, 2 * v[3][0]);
}
if (v[1].size() >= 2) {
mpr[i][2].first = v[1][0] + v[1][1];
mpr[i][2].second = 2 * v[1][0] + v[1][1];
}
if (v[2].size() >= 1 && v[1].size() >= 1) {
mpr[i][2].first = max(mpr[i][2].first, v[2][0] + v[1][0]);
mpr[i][2].second = max(mpr[i][2].second,
max(2 * v[2][0] + v[1][0], v[2][0] + 2 * v[1][0]));
}
if (v[1].size() >= 3) {
mpr[i][3].first = v[1][0] + v[1][1] + v[1][2];
mpr[i][3].second = 2 * v[1][0] + v[1][1] + v[1][2];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 10; j++) dp[i][j] = dp[i - 1][j];
for (int j = 1; j <= 10; j++) {
for (int k = 1; k <= 3; k++) {
if (mpr[i][k].first != 0) {
if (j == 10) {
if (dp[i - 1][j - k] >= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + mpr[i][k].second);
} else if (j - k == 0) {
if (dp[i - 1][10] < 0) {
dp[i][j] = max(dp[i][j], dp[i - 1][0] + mpr[i][k].first);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][10] + mpr[i][k].first);
}
} else if ((j - k) < 0) {
if (dp[i - 1][10 + (j - k)] >= 0)
dp[i][j] =
max(dp[i][j], dp[i - 1][10 + (j - k)] + mpr[i][k].second);
} else if ((j - k) > 0) {
if (dp[i - 1][j - k] >= 0)
dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + mpr[i][k].first);
}
}
}
}
}
long long ans = 0;
for (int i = 1; i <= 10; i++) ans = max(ans, dp[n][i]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long dp[200005][15];
void Solve() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 10; j++) {
dp[i][j] = -100000000001ll;
}
}
int total = 0;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
int k;
scanf("%d", &k);
long long a1, a2, a3, a4, a5;
a1 = a2 = a3 = a4 = a5 = -100000000001ll;
for (int j = 1; j <= k; j++) {
int c;
long long d;
scanf("%d%I64d", &c, &d);
if (c == 1) {
if (d > a1) {
a3 = a2;
a2 = a1;
a1 = d;
} else if (d > a2) {
a3 = a2;
a2 = d;
} else if (d > a3) {
a3 = d;
}
} else if (c == 2) {
a4 = max(a4, d);
} else if (c == 3) {
a5 = max(a5, d);
}
}
long long dp2[4][2];
dp2[3][0] = a1 + a2 + a3;
dp2[3][1] = a1 + a1 + a2 + a3;
dp2[2][0] = a1 + max(a2, a4);
dp2[2][1] = a1 + max(a2, a4) + max(a1, max(a2, a4));
dp2[1][0] = max(a1, max(a4, a5));
dp2[1][1] = dp2[1][0] << 1;
for (int j = 0; j < 10; j++) {
if (j < 3) {
dp[i][j] = max(dp[i][j], dp[i - 1][j + 7] + dp2[3][1]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][j - 3] + dp2[3][0]);
}
if (j < 2) {
dp[i][j] = max(dp[i][j], dp[i - 1][j + 8] + dp2[2][1]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][j - 2] + dp2[2][0]);
}
if (j < 1) {
dp[i][j] = max(dp[i][j], dp[i - 1][j + 9] + dp2[1][1]);
} else {
dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + dp2[1][0]);
}
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) {
ans = max(ans, dp[n][i]);
}
printf("%I64d", ans);
}
int main() {
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200204;
long long dp[maxn][10];
vector<long long> b[maxn][4];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
vector<pair<long long, long long>> a(k);
for (int j = 0; j < k; j++) {
long long c, x;
cin >> c >> x;
a[j] = {x, c};
}
sort(a.rbegin(), a.rend());
for (int j = 0; j < k; j++) {
if (a[j].second == 1 && int(b[i][1].size()) < 3) {
b[i][1].push_back(a[j].first);
}
if (a[j].second == 2 && int(b[i][2].size()) < 1) {
b[i][2].push_back(a[j].first);
}
if (a[j].second == 3 && int(b[i][3].size()) < 1) {
b[i][3].push_back(a[j].first);
}
}
sort(b[i][1].rbegin(), b[i][1].rend());
}
for (int i = 0; i <= n; i++)
for (int j = 0; j < 10; j++) dp[i][j] = -1;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 10; j++) {
if (dp[i][j] == -1) {
continue;
}
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if (int(b[i][1].size()) > 0) {
dp[i + 1][(j + 1) % 10] =
max(dp[i + 1][(j + 1) % 10],
dp[i][j] + (j + 1 == 10 ? 2 * b[i][1][0] : b[i][1][0]));
}
if (int(b[i][1].size()) > 1) {
dp[i + 1][(j + 2) % 10] =
max(dp[i + 1][(j + 2) % 10],
dp[i][j] + (j + 2 >= 10 ? 2 * b[i][1][0] + b[i][1][1]
: b[i][1][0] + b[i][1][1]));
}
if (int(b[i][1].size()) > 2) {
dp[i + 1][(j + 3) % 10] = max(
dp[i + 1][(j + 3) % 10],
dp[i][j] + (j + 3 >= 10 ? 2 * b[i][1][0] + b[i][1][1] + +b[i][1][2]
: b[i][1][0] + b[i][1][1] + b[i][1][2]));
}
if (int(b[i][2].size()) > 0) {
dp[i + 1][(j + 1) % 10] =
max(dp[i + 1][(j + 1) % 10],
dp[i][j] + (j + 1 == 10 ? 2 * b[i][2][0] : b[i][2][0]));
}
if (int(b[i][1].size()) > 0 && int(b[i][2].size()) > 0) {
dp[i + 1][(j + 2) % 10] =
max(dp[i + 1][(j + 2) % 10],
dp[i][j] + (j + 2 >= 10 ? 2 * max(b[i][2][0], b[i][1][0]) +
min(b[i][2][0], b[i][1][0])
: b[i][1][0] + b[i][2][0]));
}
if (int(b[i][3].size()) > 0) {
dp[i + 1][(j + 1) % 10] =
max(dp[i + 1][(j + 1) % 10],
dp[i][j] + (j + 1 == 10 ? 2 * b[i][3][0] : b[i][3][0]));
}
}
}
long long mx = 0;
for (int i = 0; i < 10; i++) mx = max(mx, dp[n][i]);
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DEBUGGER = 0;
const long long MAX = 2e5 + 5;
const long long MOD = 1e9 + 7;
const long long INF = 9e18;
const double PI = 3.141592653589793238462;
long long addM(long long a, long long b) {
return (a += b) >= MOD ? (a -= MOD) : a;
}
long long subM(long long a, long long b) {
return (a -= b) < 0 ? (a += MOD) : a;
}
long long n, mem[MAX][11];
vector<pair<pair<long long, long long>, vector<long long> > > a;
long long dp(long long i, long long cnt) {
if (cnt >= 11) cnt -= 10;
if (i == n) return 0;
if (mem[i][cnt] != -1) return mem[i][cnt];
long long a1 = 0, a2 = 0, a3 = 0, dpi1c1 = dp(i + 1, cnt + 1);
if (a[i].first.first != -1)
a1 = a[i].first.first * (cnt == 10 ? 2 : 1) + dpi1c1;
if (a[i].first.second != -1) {
long long ad = a[i].first.second * (cnt == 10 ? 2 : 1);
long long b1 = ad + dpi1c1;
long long b2 = 0, c1 = 0;
if (a[i].second.size() != 0) {
b2 = ad + a[i].second[0] * (cnt + 1 == 10 ? 2 : 1) + dp(i + 1, cnt + 2);
c1 = a[i].second[0] * (cnt == 10 ? 2 : 1);
c1 += a[i].first.second * (cnt + 1 == 10 ? 2 : 1) + dp(i + 1, cnt + 2);
}
a2 = max({b1, b2, c1});
}
if (a[i].second.size() != 0) {
long long b2 = 0, b3 = 0, ad = a[i].second[0] * (cnt == 10 ? 2 : 1);
long long b1 = dpi1c1 + ad;
if (a[i].second.size() > 1) {
b2 = a[i].second[0] + a[i].second[1] +
a[i].second[0] * (((cnt == 10) || (cnt + 1 == 10)) ? 1 : 0) +
dp(i + 1, cnt + 2);
}
if (a[i].second.size() > 2) {
b3 = a[i].second[0] + a[i].second[1] + a[i].second[2] +
a[i].second[0] *
(((cnt == 10) || (cnt + 1 == 10) || (cnt + 2 == 10)) ? 1 : 0) +
dp(i + 1, cnt + 3);
}
a3 = max({b1, b2, b3});
}
return mem[i][cnt] = max({a1, a2, a3, dp(i + 1, cnt)});
}
void solve() {
memset(mem, -1, sizeof(mem));
n = ({
long long TEMP;
cin >> TEMP;
TEMP;
});
for (int i = 0; i < n; i++) {
long long k = ({
long long TEMP;
cin >> TEMP;
TEMP;
});
vector<long long> v[3];
while (k--) {
long long c = ({
long long TEMP;
cin >> TEMP;
TEMP;
}) -
1,
d = ({
long long TEMP;
cin >> TEMP;
TEMP;
});
v[c].push_back(d);
}
sort(v[0].begin(), v[0].end(), greater<long long>());
sort(v[1].begin(), v[1].end(), greater<long long>());
sort(v[2].begin(), v[2].end(), greater<long long>());
if (v[2].size() == 0) v[2].push_back(-1);
if (v[1].size() == 0) v[1].push_back(-1);
a.push_back({{v[2][0], v[1][0]}, v[0]});
}
({
if (DEBUGGER)
({
if (DEBUGGER)
cout << "dp(0, 1)"
<< " = " << dp(0, 1) << endl;
});
else
cout << dp(0, 1) << endl;
});
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int multipletest = 0;
if (multipletest) {
int tc;
cin >> tc;
while (tc--) solve();
} else
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[212345][10];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = (0); i < (n + 1); ++i)
for (int j = (0); j < (10); ++j) dp[i][j] = -1;
dp[0][0] = 0;
for (int i = (0); i < (n); ++i) {
int k;
cin >> k;
vector<vector<long long> > cards(4);
for (int j = (0); j < (k); ++j) {
long long c, d;
cin >> c >> d;
cards[c].push_back(d);
}
for (int j = (1); j < (4); ++j) {
sort(cards[j].begin(), cards[j].end());
reverse(cards[j].begin(), cards[j].end());
}
for (int j = (0); j < (10); ++j) {
if (dp[i][j] == -1) continue;
dp[i + 1][j] =
((dp[i + 1][j]) > (dp[i][j]) ? (dp[i + 1][j]) : (dp[i][j]));
if ((int)(cards[1]).size()) {
if (j + 1 >= 10) {
dp[i + 1][(j + 1) % 10] =
((dp[i + 1][(j + 1) % 10]) > (dp[i][j] + 2 * cards[1][0])
? (dp[i + 1][(j + 1) % 10])
: (dp[i][j] + 2 * cards[1][0]));
} else {
dp[i + 1][j + 1] = ((dp[i + 1][j + 1]) > (dp[i][j] + cards[1][0])
? (dp[i + 1][j + 1])
: (dp[i][j] + cards[1][0]));
}
}
if ((int)(cards[1]).size() > 1) {
if (j + 2 >= 10) {
dp[i + 1][(j + 2) % 10] =
((dp[i + 1][(j + 2) % 10]) >
(dp[i][j] + 2 * cards[1][0] + cards[1][1])
? (dp[i + 1][(j + 2) % 10])
: (dp[i][j] + 2 * cards[1][0] + cards[1][1]));
} else {
dp[i + 1][j + 2] =
((dp[i + 1][j + 2]) > (dp[i][j] + cards[1][0] + cards[1][1])
? (dp[i + 1][j + 2])
: (dp[i][j] + cards[1][0] + cards[1][1]));
}
}
if ((int)(cards[2]).size()) {
if (j + 1 >= 10) {
dp[i + 1][(j + 1) % 10] =
((dp[i + 1][(j + 1) % 10]) > (dp[i][j] + 2 * cards[2][0])
? (dp[i + 1][(j + 1) % 10])
: (dp[i][j] + 2 * cards[2][0]));
} else {
dp[i + 1][(j + 1) % 10] =
((dp[i + 1][(j + 1) % 10]) > (dp[i][j] + cards[2][0])
? (dp[i + 1][(j + 1) % 10])
: (dp[i][j] + cards[2][0]));
}
}
if ((int)(cards[1]).size() > 2) {
if (j + 3 >= 10) {
dp[i + 1][(j + 3) % 10] =
((dp[i + 1][(j + 3) % 10]) >
(dp[i][j] + 2 * cards[1][0] + cards[1][1] + cards[1][2])
? (dp[i + 1][(j + 3) % 10])
: (dp[i][j] + 2 * cards[1][0] + cards[1][1] + cards[1][2]));
} else {
dp[i + 1][(j + 3) % 10] =
((dp[i + 1][(j + 3) % 10]) >
(dp[i][j] + cards[1][0] + cards[1][1] + cards[1][2])
? (dp[i + 1][(j + 3) % 10])
: (dp[i][j] + cards[1][0] + cards[1][1] + cards[1][2]));
}
}
if ((int)(cards[1]).size() && (int)(cards[2]).size()) {
if (j + 2 >= 10) {
dp[i + 1][(j + 2) % 10] =
((dp[i + 1][(j + 2) % 10]) >
(dp[i][j] +
2 * ((cards[1][0]) > (cards[2][0]) ? (cards[1][0])
: (cards[2][0])) +
((cards[1][0]) < (cards[2][0]) ? (cards[1][0])
: (cards[2][0])))
? (dp[i + 1][(j + 2) % 10])
: (dp[i][j] +
2 * ((cards[1][0]) > (cards[2][0]) ? (cards[1][0])
: (cards[2][0])) +
((cards[1][0]) < (cards[2][0]) ? (cards[1][0])
: (cards[2][0]))));
} else {
dp[i + 1][(j + 2) % 10] =
((dp[i + 1][(j + 2) % 10]) >
(dp[i][j] +
((cards[1][0]) > (cards[2][0]) ? (cards[1][0])
: (cards[2][0])) +
((cards[1][0]) < (cards[2][0]) ? (cards[1][0])
: (cards[2][0])))
? (dp[i + 1][(j + 2) % 10])
: (dp[i][j] +
((cards[1][0]) > (cards[2][0]) ? (cards[1][0])
: (cards[2][0])) +
((cards[1][0]) < (cards[2][0]) ? (cards[1][0])
: (cards[2][0]))));
}
}
if ((int)(cards[3]).size()) {
if (j + 1 >= 10) {
dp[i + 1][(j + 1) % 10] =
((dp[i + 1][(j + 1) % 10]) > (dp[i][j] + 2 * cards[3][0])
? (dp[i + 1][(j + 1) % 10])
: (dp[i][j] + 2 * cards[3][0]));
} else {
dp[i + 1][(j + 1) % 10] =
((dp[i + 1][(j + 1) % 10]) > (dp[i][j] + cards[3][0])
? (dp[i + 1][(j + 1) % 10])
: (dp[i][j] + cards[3][0]));
}
}
}
}
long long ans = 0;
for (int j = (0); j < (10); ++j) {
ans = ((ans) > (dp[n][j]) ? (ans) : (dp[n][j]));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX_N = 2e5;
vector<ll> card[3][MAX_N];
ll dp[10][MAX_N];
int n;
ll rec(int t, int p) {
if (p == n) return 0;
ll& ret = dp[t][p];
if (ret != -1) return ret;
ret = rec(t, p + 1);
int i;
for (i = 0; i < card[0][p].size(); i++)
ret = max(ret, rec((t + 1) % 10, p + 1) + (!t ? 2 : 1) * card[0][p][i]);
if (!card[1][p].empty())
ret = max(ret, rec((t + 1) % 10, p + 1) + (!t ? 2 : 1) * card[1][p][0]);
if (!card[2][p].empty())
ret = max(ret, rec((t + 1) % 10, p + 1) + (!t ? 2 : 1) * card[2][p][0]);
if (card[0][p].size() > 1)
ret = max(ret, rec((t + 2) % 10, p + 1) +
(!t || t + 2 > 10 ? 2 : 1) * card[0][p][0] +
card[0][p][1]);
if (!card[0][p].empty() && !card[1][p].empty())
ret = max(ret, rec((t + 2) % 10, p + 1) +
(!t || t + 2 > 10 ? 2 : 1) *
max(card[0][p][0], card[1][p].back()) +
min(card[0][p][0], card[1][p].back()));
if (card[0][p].size() == 3)
ret = max(ret, rec((t + 3) % 10, p + 1) +
(!t || t + 3 > 10 ? 2 : 1) * card[0][p][0] +
card[0][p][1] + card[0][p][2]);
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
int k, i, j;
ll cx, dx;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
for (j = 0; j < k; j++) {
scanf("%lld%lld", &cx, &dx);
cx--;
if (cx) {
if (card[cx][i].empty())
card[cx][i].push_back(dx);
else
card[cx][i].back() = max(card[cx][i].back(), dx);
} else {
if (card[cx][i].size() < 3) {
card[cx][i].push_back(dx);
sort(card[cx][i].begin(), card[cx][i].end(),
[](const ll& a, const ll& b) { return a > b; });
} else {
card[cx][i][2] = max(card[cx][i][2], dx);
sort(card[cx][i].begin(), card[cx][i].end(),
[](const ll& a, const ll& b) { return a > b; });
}
}
}
}
printf("%lld", rec(1, 0));
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
long long D[2][10];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
((void)0);
((void)0);
((void)0);
int N;
long long ans = 0;
memset(D, -1, sizeof(D));
cin >> N;
D[0][0] = 0;
for (int i = 1; i <= N; i++) {
int k, p;
long long q, a1 = -1, a2 = -1, a3 = -1, b = -1, c = -1, t31 = -1, t32 = -1,
t21 = -1, t22 = -1, t1 = -1;
for (int j = 0; j < 10; j++) D[i & 1][j] = -1;
for (cin >> k; k--;) {
cin >> p >> q;
if (p == 1) {
if (a1 < q) {
a3 = a2;
a2 = a1;
a1 = q;
} else if (a2 < q) {
a3 = a2;
a2 = q;
} else if (a3 < q)
a3 = q;
} else if (p == 2)
b = max(b, q);
else
c = max(c, q);
}
if (a3 != -1) {
t31 = a1 + a2 + a3;
t32 = t31 + max({a1, a2, a3});
}
if (a1 != -1 && b != -1) {
t21 = a1 + b;
t22 = t21 + max(a1, b);
}
if (a2 != -1) {
t21 = max(t21, a1 + a2);
t22 = max(t22, a1 + a2 + max(a1, a2));
}
t1 = max({a1, b, c});
for (int j = 0; j < 10; j++)
if (D[(i - 1) & 1][j] != -1) {
D[i & 1][j] = max(D[i & 1][j], D[(i - 1) & 1][j]);
D[i & 1][(j + 1) % 10] = max(D[i & 1][(j + 1) % 10],
D[(i - 1) & 1][j] + (j == 9 ? 2 : 1) * t1);
if (t21 != -1)
D[i & 1][(j + 2) % 10] = max(
D[i & 1][(j + 2) % 10], D[(i - 1) & 1][j] + (j >= 8 ? t22 : t21));
if (t31 != -1)
D[i & 1][(j + 3) % 10] = max(
D[i & 1][(j + 3) % 10], D[(i - 1) & 1][j] + (j >= 7 ? t32 : t31));
}
}
for (int i = 0; i < 10; i++) ans = max(ans, D[N & 1][i]);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[200005][10];
long long arr[200005][2][4];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long n;
cin >> n;
for (long long i = 0; i < 200005; i++)
for (long long j = 0; j < 10; j++) dp[i][j] = -1e18;
dp[0][0] = 0;
long long ans = -1e18;
for (long long i = 0; i < n; i++) {
vector<long long> co[4];
long long k;
cin >> k;
for (long long j = 0; j < k; j++) {
long long c, d;
cin >> c >> d;
co[c].push_back(d);
}
for (long long j = 0; j < 2; j++)
for (long long l = 1; l < 4; l++) arr[i][j][l] = -1e18;
sort((co[1]).begin(), (co[1]).end());
sort((co[2]).begin(), (co[2]).end());
sort((co[3]).begin(), (co[3]).end());
reverse((co[1]).begin(), (co[1]).end());
reverse((co[2]).begin(), (co[2]).end());
reverse((co[3]).begin(), (co[3]).end());
if ((long long)co[1].size()) {
arr[i][0][1] = co[1][0];
arr[i][1][1] = 2 * co[1][0];
}
if ((long long)co[1].size() > 1) {
arr[i][0][2] = co[1][0] + co[1][1];
arr[i][1][2] = 2 * co[1][0] + co[1][1];
}
if ((long long)co[2].size()) {
arr[i][0][1] = max(co[2][0], arr[i][0][1]);
arr[i][1][1] = max(2 * co[2][0], arr[i][1][1]);
}
if ((long long)co[1].size() > 2) {
arr[i][0][3] = co[1][0] + co[1][1] + co[1][2];
arr[i][1][3] = 2 * co[1][0] + co[1][1] + co[1][2];
}
if ((long long)co[2].size() && ((long long)co[1].size())) {
arr[i][0][2] = max(co[2][0] + co[1][0], arr[i][0][2]);
arr[i][1][2] =
max(co[2][0] + co[1][0] + max(co[2][0], co[1][0]), arr[i][1][2]);
}
if ((long long)co[3].size()) {
arr[i][0][1] = max(co[3][0], arr[i][0][1]);
arr[i][1][1] = max(2 * co[3][0], arr[i][1][1]);
}
for (long long j = 0; j < 10; j++) dp[i + 1][j] = dp[i][j];
for (long long j = 0; j < 10; j++) {
for (long long l = 1; l < 4; l++) {
if (j + l < 10) {
dp[i + 1][j + l] = max(dp[i][j] + arr[i][0][l], dp[i + 1][j + l]);
} else {
dp[i + 1][j + l - 10] =
max(dp[i][j] + arr[i][1][l], dp[i + 1][j + l - 10]);
}
}
}
}
for (long long j = 0; j < 10; j++) ans = max(ans, dp[n][j]);
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
mt19937 rng(steady_clock::now().time_since_epoch().count());
const long long mod = 998244353;
long long madd(long long a, long long b) { return (a + b) % mod; }
long long msub(long long a, long long b) {
return (((a - b) % mod) + mod) % mod;
}
long long mmul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long mpow(long long base, long long exp) {
long long res = 1;
while (exp) {
if (exp % 2 == 1) {
res = (res * base) % mod;
}
exp >>= 1;
base = (base * base) % mod;
}
return res;
}
long long minv(long long base) { return mpow(base, mod - 1); }
long long mdiv(long long a, long long b) { return mmul(a, minv(b)); }
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
bool prime[10000006];
void sieve(int n) {
for (long long i = 0; i < n + 1; i++) prime[i] = 1;
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
prime[1] = prime[0] = 0;
}
long long n, q, Q, T, m, k, l, r, x, y, z, g;
vector<long long> turns[200002][3];
long long dp[200001][11];
long long a[11];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> k;
for (long long j = 0; j < k; j++) {
cin >> x >> y;
turns[i + 1][--x].push_back(y);
}
for (long long j = 0; j < 3; j++) {
sort(turns[i + 1][j].begin(), turns[i + 1][j].end());
reverse(turns[i + 1][j].begin(), turns[i + 1][j].end());
}
}
for (long long i = 0; i < n + 1; i++)
for (long long j = 0; j < 10; j++) dp[i][j] = -1;
for (long long j = 0; j < 10; j++) dp[0][j] = -1;
dp[0][0] = 0;
for (long long i = 1; i < n + 1; i++) {
for (long long j = 0; j < 10; j++) a[j] = -1;
for (long long j = 0; j < 10; j++) {
if (dp[i - 1][j] != -1) {
a[j] = max(a[j], dp[i - 1][j]);
if (j + 1 > 9) {
if (turns[i][0].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + 2 * turns[i][0][0]);
if (turns[i][1].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + 2 * turns[i][1][0]);
if (turns[i][2].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + 2 * turns[i][2][0]);
} else {
if (turns[i][0].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + turns[i][0][0]);
if (turns[i][1].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + turns[i][1][0]);
if (turns[i][2].size())
a[(j + 1) % 10] =
max(a[(j + 1) % 10], dp[i - 1][j] + turns[i][2][0]);
}
if (j + 2 > 9) {
if (turns[i][0].size() > 1)
a[(j + 2) % 10] =
max(a[(j + 2) % 10],
dp[i - 1][j] + 2 * turns[i][0][0] + turns[i][0][1]);
if (turns[i][0].size() && turns[i][1].size())
a[(j + 2) % 10] =
max(a[(j + 2) % 10],
dp[i - 1][j] + 2 * max(turns[i][0][0], turns[i][1][0]) +
min(turns[i][0][0], turns[i][1][0]));
} else {
if (turns[i][0].size() > 1)
a[(j + 2) % 10] =
max(a[(j + 2) % 10],
dp[i - 1][j] + turns[i][0][0] + turns[i][0][1]);
if (turns[i][0].size() && turns[i][1].size())
a[(j + 2) % 10] =
max(a[(j + 2) % 10],
dp[i - 1][j] + turns[i][0][0] + turns[i][1][0]);
}
if (j + 3 > 9) {
if (turns[i][0].size() > 2)
a[(j + 3) % 10] =
max(a[(j + 3) % 10], dp[i - 1][j] + 2 * turns[i][0][0] +
turns[i][0][1] + turns[i][0][2]);
} else {
if (turns[i][0].size() > 2)
a[(j + 3) % 10] =
max(a[(j + 3) % 10], dp[i - 1][j] + turns[i][0][0] +
turns[i][0][1] + turns[i][0][2]);
}
}
}
for (long long j = 0; j < 10; j++) dp[i][j] = a[j];
}
long long ans = 0;
for (long long i = 0; i < 10; i++) ans = max(dp[n][i], ans);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int n1, n2, n3;
long long int dp[200010][15];
vector<long long int> damage[200010][5];
long long int DP(int i, int k) {
if (dp[i][k] != -1) return dp[i][k];
if (i == 0 && k == 0) return dp[i][k] = 0;
if (i == 0 && k != 0) return dp[i][k] = -1000000000000000000LL;
long long int ans = DP(i - 1, k);
if (damage[i][1].size() > 2) {
long long int sum = damage[i][1][0] + damage[i][1][1] + damage[i][1][2];
if (k > 2)
ans = max(ans, DP(i - 1, k - 3) - sum);
else {
long long int doubleDamage =
min(min(damage[i][1][0], damage[i][1][1]), damage[i][1][2]);
ans = max(ans, DP(i - 1, 7 + k) - sum - doubleDamage);
}
}
if (damage[i][2].size() > 0 && damage[i][1].size() > 0) {
long long int sum = damage[i][2][0] + damage[i][1][0];
if (k > 1)
ans = max(ans, DP(i - 1, k - 2) - sum);
else {
long long int doubleDamage = min(damage[i][2][0], damage[i][1][0]);
ans = max(ans, DP(i - 1, 8 + k) - sum - doubleDamage);
}
}
if (damage[i][1].size() > 1) {
long long int sum = damage[i][1][0] + damage[i][1][1];
if (k > 1)
ans = max(ans, DP(i - 1, k - 2) - sum);
else {
long long int doubleDamage = min(damage[i][1][0], damage[i][1][1]);
ans = max(ans, DP(i - 1, 8 + k) - sum - doubleDamage);
}
}
for (int g = 1; g <= 3; g++) {
if (damage[i][g].size() > 0) {
if (k > 0)
ans = max(ans, DP(i - 1, k - 1) - damage[i][g][0]);
else
ans = max(ans, DP(i - 1, 9) - 2 * damage[i][g][0]);
}
}
return dp[i][k] = ans;
}
int main() {
scanf("%d", &n);
memset(dp, -1, sizeof(dp));
for (int g = 1; g <= n; g++) {
scanf("%d", &n1);
for (int h = 0; h < n1; h++) {
scanf("%d %d", &n2, &n3);
damage[g][n2].push_back(-n3);
}
for (int h = 1; h <= 3; h++) {
sort(damage[g][h].begin(), damage[g][h].end());
if (damage[g][h].size() > 3) damage[g][h].resize(3);
}
}
long long int ans = 0;
for (int g = 0; g < 10; g++) ans = max(ans, DP(n, g));
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long cost3 = 0;
long long cost2 = 0;
long long cost1a = 0, cost1b = 0, cost1c = 0;
void add(pair<long long, long long> v) {
if (v.first == 3) cost3 = max(cost3, v.second);
if (v.first == 2) cost2 = max(cost2, v.second);
if (v.first == 1) {
if (cost1a <= v.second) {
cost1c = cost1b;
cost1b = cost1a;
cost1a = v.second;
return;
}
if (cost1b <= v.second) {
cost1c = cost1b;
cost1b = v.second;
return;
}
if (cost1c < v.second) cost1c = v.second;
}
}
long long ret1() { return max({cost3, cost2, cost1a}); }
pair<long long, long long> ret2() {
pair<long long, long long> ret = {cost1a, max(cost2, cost1b)};
if (ret.first < ret.second) swap(ret.first, ret.second);
return ret;
}
pair<long long, pair<long long, long long> > ret3() {
return {cost1a, {cost1b, cost1c}};
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, u, v, k;
cin >> n;
vector<node> vec(n);
for (int i(0), ThkMk(n); i < ThkMk; ++i) {
cin >> k;
for (int j(0), ThkMk(k); j < ThkMk; ++j) {
cin >> u >> v;
vec[i].add({u, v});
}
}
vector<long long> dp(10, -1);
dp[0] = 0;
for (int i(0), ThkMk(n); i < ThkMk; ++i) {
long long x = vec[i].ret1();
vector<long long> nw = dp;
for (int k(0), ThkMk(10); k < ThkMk; ++k) {
if (dp[k] != -1) {
if (k == 9)
nw[0] = max(nw[0], dp[9] + x * 2LL);
else
nw[k + 1] = max(nw[k + 1], dp[k] + x);
}
}
x = vec[i].ret2().first;
long long y = vec[i].ret2().second;
if (y == 0) {
dp = nw;
continue;
}
for (int k(0), ThkMk(10); k < ThkMk; ++k) {
if (dp[k] != -1) {
if (k == 9) nw[1] = max(nw[1], dp[9] + x * 2LL + y);
if (k == 8) nw[0] = max(nw[0], dp[8] + x * 2LL + y);
if (k < 8) nw[k + 2] = max(nw[k + 2], dp[k] + x + y);
}
}
x = vec[i].ret3().first;
y = vec[i].ret3().second.first;
long long z = vec[i].ret3().second.second;
if (z == 0) {
dp = nw;
continue;
}
for (int k(0), ThkMk(10); k < ThkMk; ++k) {
if (dp[k] != -1) {
if (k == 9) nw[2] = max(nw[2], dp[9] + x * 2LL + y + z);
if (k == 8) nw[1] = max(nw[1], dp[8] + x * 2LL + y + z);
if (k == 7) nw[0] = max(nw[0], dp[7] + x * 2LL + y + z);
if (k < 7) nw[k + 3] = max(nw[k + 3], dp[k] + x + y + z);
}
}
dp = nw;
}
long long mx = dp[0];
for (int i(1), ThkMk(10); i < ThkMk; ++i) mx = max(mx, dp[i]);
cout << mx << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 1e18 + 7, mod = 1e9 + 7;
const long long N = 2e5 + 5;
long long n, dp[N][10];
vector<long long> vc[N][4];
signed main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
long long cards;
cin >> cards;
for (long long j = 1; j <= cards; j++) {
long long cost, val;
cin >> cost >> val;
vc[i][cost].push_back(val);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= 3; j++) {
while (vc[i][j].size() < (3 / j)) vc[i][j].push_back(-oo);
sort(vc[i][j].begin(), vc[i][j].end(), greater<long long>());
}
}
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j < 10; j++) dp[i][j] = -oo;
}
dp[0][0] = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < 10; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
if (j)
dp[i][j] =
max(dp[i][j], dp[i - 1][(j + 9) % 10] +
max(max(vc[i][1][0], vc[i][2][0]), vc[i][3][0]));
if (j >= 2)
dp[i][j] = max(
dp[i][j], dp[i - 1][(j + 8) % 10] + max(vc[i][1][0] + vc[i][2][0],
vc[i][1][0] + vc[i][1][1]));
if (j >= 3)
dp[i][j] = max(dp[i][j], dp[i - 1][(j + 7) % 10] + vc[i][1][0] +
vc[i][1][1] + vc[i][1][2]);
}
dp[i][0] =
max(dp[i][0],
dp[i - 1][9] + max(max(vc[i][1][0], vc[i][2][0]), vc[i][3][0]) * 2);
dp[i][0] =
max(dp[i][0], dp[i - 1][8] + max(vc[i][1][0] + vc[i][2][0] +
max(vc[i][1][0], vc[i][2][0]),
vc[i][1][0] * 2 + vc[i][1][1]));
dp[i][1] =
max(dp[i][1], dp[i - 1][9] + max(vc[i][1][0] + vc[i][2][0] +
max(vc[i][1][0], vc[i][2][0]),
vc[i][1][0] * 2 + vc[i][1][1]));
dp[i][0] = max(dp[i][0],
dp[i - 1][7] + vc[i][1][0] * 2 + vc[i][1][1] + vc[i][1][2]);
dp[i][1] = max(dp[i][1],
dp[i - 1][8] + vc[i][1][0] * 2 + vc[i][1][1] + vc[i][1][2]);
dp[i][2] = max(dp[i][2],
dp[i - 1][9] + vc[i][1][0] * 2 + vc[i][1][1] + vc[i][1][2]);
for (long long j = 0; j < 10; j++) dp[i][j] = max(dp[i][j], -oo);
}
long long answ = -1;
for (long long i = 0; i < 10; i++) answ = max(answ, dp[n][i]);
cout << answ;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long dp[10];
dp[0] = 0;
for (int i = 1; i < 10; ++i) {
dp[i] = -1e18;
}
while (n-- > 0) {
int k;
cin >> k;
multiset<int> us[3];
for (int i = 0; i < k; ++i) {
int a, b;
cin >> a >> b;
--a;
b = -b;
us[a].insert(b);
}
long long temp[10];
for (int i = 0; i < 10; ++i) {
temp[i] = dp[i];
}
if (us[2].size()) {
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 1) % 10;
if (to) {
temp[to] = max(temp[to], dp[i] - *us[2].begin());
} else {
temp[to] = max(temp[to], dp[i] - (*us[2].begin()) * 2);
}
}
}
if (us[1].size()) {
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 1) % 10;
if (to) {
temp[to] = max(temp[to], dp[i] - *us[1].begin());
} else {
temp[to] = max(temp[to], dp[i] - (*us[1].begin()) * 2);
}
}
}
if (us[1].size() && us[0].size()) {
int kek = 0;
kek -= *us[1].begin();
kek -= *us[0].begin();
int mx = max(-*us[1].begin(), -*us[0].begin());
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + 2) % 10;
if (to > i) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
}
if (us[0].size()) {
long long kek = 0;
int mx = 0;
for (int h = 1; h <= 3; ++h) {
if (!us[0].size()) {
break;
}
kek += -*us[0].begin();
mx = max(mx, -*us[0].begin());
for (int i = 0; i < 10; ++i) {
if (dp[i] == -1e18) continue;
int to = (i + h) % 10;
if (to > i) {
temp[to] = max(temp[to], dp[i] + kek);
} else {
temp[to] = max(temp[to], dp[i] + kek + mx);
}
}
us[0].erase(us[0].begin());
}
}
for (int i = 0; i < 10; ++i) {
dp[i] = temp[i];
}
}
long long ans = -1e18;
for (int i = 0; i < 10; ++i) {
ans = max(ans, dp[i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void use_cio() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto x : V) os << x << ", ";
return os << "]";
}
template <typename... Args>
void dbg(Args... args) {
((cerr << args << " "), ...);
cerr << "\n";
}
long long dp[200010][10];
int main() {
use_cio();
int n;
cin >> n;
for (int i = 0; i < (10); i++) dp[0][i] = -1;
dp[0][0] = 0;
for (int i = 0; i < (n); i++) {
int k;
cin >> k;
vector<long long> cost1, cost2, cost3;
for (int j = 0; j < (k); j++) {
long long c, d;
cin >> c >> d;
if (c == 1) cost1.push_back(d);
if (c == 2) cost2.push_back(d);
if (c == 3) cost3.push_back(d);
}
sort(cost1.rbegin(), cost1.rend());
sort(cost2.rbegin(), cost2.rend());
sort(cost3.rbegin(), cost3.rend());
vector<tuple<long long, long long, long long>> vc;
if (cost1.size()) vc.push_back({1, cost1[0], 2LL * cost1[0]});
if (cost2.size()) vc.push_back({1, cost2[0], 2LL * cost2[0]});
if (cost3.size()) vc.push_back({1, cost3[0], 2LL * cost3[0]});
if (cost1.size() >= 2)
vc.push_back({2, cost1[0] + cost1[1], 2LL * cost1[0] + cost1[1]});
if (cost1.size() >= 3)
vc.push_back({3, cost1[0] + cost1[1] + cost1[2],
2LL * cost1[0] + cost1[1] + cost1[2]});
if (cost1.size() and cost2.size())
vc.push_back({2, cost1[0] + cost2[0],
cost1[0] + cost2[0] + max(cost1[0], cost2[0])});
for (int j = 0; j < (10); j++) dp[i + 1][j] = dp[i][j];
for (int j = 0; j < (10); j++) {
for (auto [nn, d, dd] : vc) {
int nj = j + nn;
if (dp[i][j] == -1) continue;
if (nj >= 10)
dp[i + 1][nj % 10] = max(dp[i + 1][nj % 10], dp[i][j] + dd);
else
dp[i + 1][nj] = max(dp[i + 1][nj], dp[i][j] + d);
}
}
}
cout << *max_element(dp[n], dp[n] + 10) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
using ll = long long;
using ii = pair<int, int>;
using vi = vector<ll>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vii = vector<ii>;
using vvii = vector<vii>;
using vb = vector<bool>;
using vvb = vector<vb>;
int n;
vvvi cards;
vvi dp;
ll f(int turn, int rem) {
if (turn == n) return 0;
if (dp[turn][rem] != -1) return dp[turn][rem];
ll ans = f(turn + 1, rem);
if (cards[turn][1].size() >= 1) {
ans = max(ans, f(turn + 1, (rem + 1) % 10) +
cards[turn][1][0] * (rem == 9 ? 2 : 1));
}
if (cards[turn][1].size() >= 2) {
ans = max(ans, f(turn + 1, (rem + 2) % 10) +
cards[turn][1][0] * (rem >= 8 ? 2 : 1) +
cards[turn][1][1]);
}
if (cards[turn][2].size() >= 1) {
ans = max(ans, f(turn + 1, (rem + 1) % 10) +
cards[turn][2][0] * (rem == 9 ? 2 : 1));
}
if (cards[turn][1].size() >= 1 && cards[turn][2].size() >= 1) {
ll mx = max(cards[turn][1][0], cards[turn][2][0]);
ll mn = min(cards[turn][1][0], cards[turn][2][0]);
ans = max(ans, f(turn + 1, (rem + 2) % 10) + mx * (rem >= 8 ? 2 : 1) + mn);
}
if (cards[turn][1].size() >= 3) {
ans = max(ans, f(turn + 1, (rem + 3) % 10) +
cards[turn][1][0] * (rem >= 7 ? 2 : 1) +
cards[turn][1][1] + cards[turn][1][2]);
}
if (cards[turn][3].size() >= 1) {
ans = max(ans, f(turn + 1, (rem + 1) % 10) +
cards[turn][3][0] * (rem == 9 ? 2 : 1));
}
return dp[turn][rem] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
cards = vvvi(n, vvi(4));
dp = vvi(n, vi(10, -1));
for (int i = 0; i < n; i++) {
int k;
cin >> k;
while (k--) {
int c;
ll d;
cin >> c >> d;
cards[i][c].push_back(d);
}
for (int c = 1; c <= 3; c++) {
sort(cards[i][c].rbegin(), cards[i][c].rend());
}
}
cout << f(0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
struct InputReader {
char buf[1048576];
int p;
inline InputReader() { p = 1048576; }
inline void Flush() {
p = 0;
fread(buf, 1, 1048576, stdin);
}
inline char C() {
if (p >= 1048576) Flush();
return buf[p++];
}
inline char Readnum() {
char ch = C();
while (!isdigit(ch) && ch != '-') ch = C();
return ch;
}
inline void Readalpha(char &c) {
c = C();
while (!isalpha(c)) c = C();
}
int operator()() {
int ans = 0, fu = 1;
char ch = Readnum();
if (ch == '-') fu = -1, ch = C();
while (ch >= '0' && ch <= '9') {
ans = ans * 10 + ch - '0';
ch = C();
}
return ans * fu;
}
long long Readll() {
long long ans = 0LL, fu = 1LL;
char ch = Readnum();
if (ch == '-') fu = -1LL, ch = C();
while (ch >= '0' && ch <= '9') {
ans = ans * 10LL + ch - '0';
ch = C();
}
return ans * fu;
}
inline void Readstring(string &x) {
x.clear();
char ch = C();
while (!isdigit(ch) && !isalpha(ch) && ch != '#' && ch != '.') ch = C();
while (isdigit(ch) || isalpha(ch) || ch == '#' || ch == '.') {
x += ch;
ch = C();
}
}
inline void Readchstring(char s[]) {
int len = 0;
char ch = C();
while (!isdigit(ch) && !isalpha(ch)) ch = C();
while (isdigit(ch) || isalpha(ch)) {
s[len++] = ch;
ch = C();
}
s[len] = '\0';
}
inline void Specialread(char &c) {
c = C();
while (!isdigit(c) && !isalpha(c) && c != '#' && c != '.' && c != '=' &&
c != 'B')
c = C();
}
} In;
inline void Read(int &x) { x = In(); }
inline void Read(int &x, int &y) {
x = In();
y = In();
}
inline void Read(int &x1, int &x2, int &x3) {
x1 = In();
x2 = In();
x3 = In();
}
inline void Read(int &x1, int &x2, int &x3, int &x4) {
x1 = In();
x2 = In();
x3 = In();
x4 = In();
}
inline void Read(long long &x) { x = In.Readll(); }
inline void Read(long long &x, long long &y) {
x = In.Readll();
y = In.Readll();
}
inline void Read(long long &x1, long long &x2, long long &x3) {
x1 = In.Readll();
x2 = In.Readll();
x3 = In.Readll();
}
inline void Read(long long &x1, long long &x2, long long &x3, long long &x4) {
x1 = In.Readll();
x2 = In.Readll();
x3 = In.Readll();
x4 = In.Readll();
}
template <typename T>
void Read(T a[], int st, int ed) {
for (int(i) = (st); (i) <= (ed); ++(i)) Read(a[i]);
}
inline void FILEIO() {}
inline void FILEIO(string pname) {
freopen((pname + ".in").c_str(), "r", stdin);
freopen((pname + ".out").c_str(), "w", stdout);
}
inline void FILEIO_OICONTEST(string pname) {
freopen((pname + ".in").c_str(), "r", stdin);
freopen((pname + ".out").c_str(), "w", stdout);
}
void Printtime() {}
void END() {
Printtime();
exit(0);
}
template <typename T>
void END(T mes) {
cout << mes << endl;
END();
}
template <typename T>
void Print(T a[], int s, int t, char sp = ' ', char ed = '\n') {
if (s > t) return;
for (int i = s; i < t; i++) cout << a[i] << sp;
cout << a[t] << ed;
cout.flush();
}
template <typename T>
void Print(T a, int s = 0, int t = -1, char sp = ' ', char ed = '\n') {
if (t == -1) t = a.size() - 1;
for (int i = s; i <= t; i++) cout << a[i] << sp;
cout << ed;
cout.flush();
}
vector<int> Range(int l, int r) {
vector<int> ret{};
for (int(i) = (l); (i) <= (r); ++(i)) ret.push_back(i);
return ret;
}
int n;
vector<pair<pair<int, long long>, int>> a[524288];
vector<long long> ca[524288][4];
long long mem[524288][16];
long long Dfs(int round, int mod10) {
if (round == n + 1) return 0;
if (~mem[round][mod10]) return mem[round][mod10];
long long ans0 = Dfs(round + 1, mod10);
long long ans1 = 0;
if (ca[round][1].size() >= 3) {
ans1 = Dfs(round + 1, (mod10 + 3) % 10) + ca[round][1][0] +
ca[round][1][1] + ca[round][1][2];
if (mod10 == 9 or mod10 == 8 or mod10 == 7) ans1 += ca[round][1][0];
}
long long ans2 = 0;
if (ca[round][1].size() and ca[round][2].size()) {
ans2 = Dfs(round + 1, (mod10 + 2) % 10) + ca[round][1][0] + ca[round][2][0];
if (mod10 == 9 or mod10 == 8) ans2 += max(ca[round][1][0], ca[round][2][0]);
}
long long ans3 = 0;
if (ca[round][3].size()) {
ans3 = Dfs(round + 1, (mod10 + 1) % 10) + ca[round][3][0];
if (mod10 == 9) ans3 += ca[round][3][0];
}
long long ans4 = 0;
if (ca[round][1].size()) {
ans4 = Dfs(round + 1, (mod10 + 1) % 10) + ca[round][1][0];
if (mod10 == 9) ans4 += ca[round][1][0];
}
long long ans5 = 0;
if (ca[round][1].size() >= 2) {
ans5 = Dfs(round + 1, (mod10 + 2) % 10) + ca[round][1][0] + ca[round][1][1];
if (mod10 == 9 or mod10 == 8) ans5 += ca[round][1][0];
}
long long ans6 = 0;
if (ca[round][2].size()) {
ans6 = Dfs(round + 1, (mod10 + 1) % 10) + ca[round][2][0];
if (mod10 == 9) ans6 += ca[round][2][0];
}
long long ans = max({ans0, ans1, ans2, ans3, ans4, ans5, ans6});
return mem[round][mod10] = ans;
}
int main() {
FILEIO();
memset(mem, -1, sizeof(mem));
Read(n);
int id = 0;
for (int(i) = 1; (i) <= (n); ++(i)) {
int k;
Read(k);
;
for (int(j) = 1; (j) <= (k); ++(j)) {
int c;
Read(c);
;
long long d;
Read(d);
;
++id;
a[i].push_back({{c, d}, id});
ca[i][c].push_back(d);
}
sort(ca[i][1].begin(), ca[i][1].end(),
[](long long x, long long y) { return x > y; });
sort(ca[i][2].begin(), ca[i][2].end(),
[](long long x, long long y) { return x > y; });
sort(ca[i][3].begin(), ca[i][3].end(),
[](long long x, long long y) { return x > y; });
}
long long ans = Dfs(1, 0);
cout << ans << endl;
END();
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> g[200005][4];
long long dp[200005][11];
long long call(long long pos, long long turn) {
if (pos == n + 1) return 0;
if (dp[pos][turn] != -1) return dp[pos][turn];
long long ret = 0;
for (long long i = 0; i <= 3 and i <= g[pos][1].size(); i++) {
for (long long j = 0; i + 2 * j <= 3 and j <= g[pos][2].size(); j++) {
for (long long k = 0; i + 2 * j + 3 * k <= 3 and k <= g[pos][3].size();
k++) {
long long mx = 0;
long long sum = 0;
for (long long I = 0; I < i; I++)
sum += g[pos][1][I], mx = max(mx, g[pos][1][I]);
for (long long J = 0; J < j; J++)
sum += g[pos][2][J], mx = max(mx, g[pos][2][J]);
for (long long K = 0; K < k; K++)
sum += g[pos][3][K], mx = max(mx, g[pos][3][K]);
if (turn + i + j + k >= 10) {
ret = max(ret, sum + mx + call(pos + 1, (turn + i + j + k) % 10));
} else {
ret = max(ret, sum + call(pos + 1, (turn + i + j + k) % 10));
}
}
}
}
return dp[pos][turn] = ret;
}
int cmp(long long x, long long y) { return x > y; }
int main() {
ios_base::sync_with_stdio(0);
memset(dp, -1, sizeof(dp));
cin >> n;
for (long long i = 1; i <= n; i++) {
long long k;
cin >> k;
for (long long j = 1; j <= k; j++) {
long long c, d;
cin >> c >> d;
g[i][c].push_back(d);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= 3; j++) {
if (!g[i][j].empty()) {
sort(g[i][j].begin(), g[i][j].end(), cmp);
}
}
}
cout << call(1, 0) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int Nmax = 100555;
int digit_tally[11];
int n, a[Nmax];
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
int digits = floor(log10(a[i])) + 1;
digit_tally[digits]++;
}
long long result = 0;
for (int i = 0; i < n; i++) {
int b[11][2];
for (int k = 0; k < 11; k++) {
b[k][0] = 0;
b[k][1] = 0;
}
int digits = 0;
int x = a[i];
while (x) {
digits++;
b[digits][0] = x % 10;
x /= 10;
b[digits][1] = x;
}
long long power = 1;
long long sparsed = 0;
for (int j = 1; j <= 10; j++) {
sparsed = (power * b[j][0] + sparsed) % mod;
power = (power * 100) % mod;
if (!digit_tally[j]) continue;
if (digits > j) {
long long rest = 1ll * b[j][1] * power;
result += (((rest * 2) % mod) * digit_tally[j]) % mod;
}
result += (((sparsed * 11) % mod) * digit_tally[j]) % mod;
}
result = result % mod;
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int mod = 998244353;
int n, a[maxn];
int len[maxn];
long long val[maxn], p10[50];
int cal(int x) {
int len = 0;
while (x) {
val[++len] += x % 10;
x /= 10;
}
return len;
}
void init() {
p10[0] = 1;
for (int i = 1; i <= 30; i++) p10[i] = p10[i - 1] * 10 % mod;
}
int main() {
init();
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
len[i] = cal(a[i]);
}
long long ans = 0;
for (int k = 1; k <= 30; k++) {
for (int i = 1; i <= n; i++) {
if (k <= len[i])
ans += p10[(k - 1) * 2] * 11 % mod * val[k] % mod, ans %= mod;
else
ans += p10[k + len[i] - 1] * 2 % mod * val[k] % mod, ans %= mod;
}
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000001], fr[1000001], sum[1000001];
int main() {
long long n, i, x, nr1, nr2, p, ans = 0, lg, v1, v2;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
x = a[i];
lg = 0;
while (x != 0) {
lg++;
x /= 10;
}
fr[lg]++;
}
for (i = 20; i >= 1; i--) sum[i] = sum[i + 1] + fr[i];
for (i = 1; i <= n; i++) {
x = a[i];
nr1 = 0;
nr2 = 0;
p = 1;
lg = 0;
while (x != 0) {
nr1 += (x % 10) * p;
nr2 = nr1 * 10;
lg++;
x /= 10;
p *= 100;
p %= 998244353;
nr1 %= 998244353;
nr2 %= 998244353;
v2 = (nr2 + x * p) % 998244353;
if (x != 0)
v2 = (v2 * fr[lg]) % 998244353;
else
v2 = (v2 * sum[lg]) % 998244353;
v1 = (nr1 + x * p) % 998244353;
if (x != 0)
v1 = (v1 * fr[lg]) % 998244353;
else
v1 = (v1 * sum[lg]) % 998244353;
ans = (ans + v1 + v2) % 998244353;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long n, a[100010], num[20], ans = 0, pw[30];
long long di(long long x) {
long long ret = 0;
while (x > 0) {
ret++;
x /= 10;
}
return ret;
}
int main() {
pw[0] = 1;
for (int i = 1; i <= 25; i++) pw[i] = pw[i - 1] * 10 % MOD;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
num[di(a[i])]++;
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 10; j++) {
int x, now = a[i], ndn = 0;
while (now > 0) {
x = now % 10;
now /= 10;
if (j >= ndn + 1)
ans =
(ans + (pw[ndn * 2] + pw[ndn * 2 + 1]) % MOD * x * num[j] % MOD) %
MOD;
else
ans = (ans + pw[ndn + j] % MOD * x * num[j] * 2 % MOD) % MOD;
ndn++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int mod = 998244353;
int a[N], num[100], b[N][20];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int x = a[i], cnt = 0;
while (x) b[i][++cnt] = x % 10, x /= 10;
num[cnt]++;
b[i][0] = cnt;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int z = 1; z <= 10; z++) {
long long cmp = 0;
long long tmp = 1;
for (int j = 1; j <= b[i][0]; j++) {
(cmp += tmp * b[i][j] % mod) %= mod;
if (j <= z)
(tmp *= 100) %= mod;
else
(tmp *= 10) %= mod;
}
(ans += cmp * num[z] % mod) %= mod;
}
}
for (int i = 1; i <= n; i++) {
for (int z = 1; z <= 10; z++) {
long long cmp = 0, tmp = 10;
for (int j = 1; j <= b[i][0]; j++) {
(cmp += tmp * b[i][j] % mod) %= mod;
if (j < z)
(tmp *= 100) %= mod;
else
(tmp *= 10) %= mod;
}
(ans += cmp * num[z] % mod) %= mod;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
void fast_in_out() {
std::ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
}
int dx[] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
int dy[] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
const long double eps = 1e-9;
const int mod = 998244353;
const int N = 1e5 + 1, M = 318;
long long ar[21];
int cnty[12];
int main() {
fast_in_out();
int n;
cin >> n;
vector<string> v(n);
int szy = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
reverse(v[i].begin(), v[i].end());
cnty[v[i].size()]++;
}
for (int i = 0; i < n; i++) {
string num = v[i];
for (int sz = 1; sz < num.size(); sz++) {
for (int j = sz; j < num.size() && cnty[sz]; j++) {
int nsz = sz + j + 1;
long long x = (num[j] - '0');
ar[nsz] += (x * (cnty[sz] * 2));
ar[nsz] %= mod;
}
for (int j = 0, nsz = 1; j < sz && cnty[sz]; j++, nsz += 2) {
long long x = (num[j] - '0');
ar[nsz] += (x * cnty[sz]);
ar[nsz + 1] += (x * cnty[sz]);
ar[nsz] %= mod;
ar[nsz + 1] %= mod;
}
}
int nn = 0;
for (int sz = num.size(); sz < 12; sz++) {
nn += cnty[sz];
}
for (int j = 0, nsz = 1; j < num.size(); j++, nsz += 2) {
int x = (num[j] - '0');
ar[nsz] += (x * nn);
ar[nsz + 1] += (x * nn);
ar[nsz] %= mod;
ar[nsz + 1] %= mod;
szy = max(szy, nsz + 1);
}
}
long long ret = 0, po = 1;
for (int i = 1; i <= szy; i++) {
if (i != 1) po *= 10;
po %= mod;
ret += (po * ar[i]);
ret %= mod;
}
cout << ret << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long n, a[100010], num[20], ans = 0, pw[30];
long long di(long long x) {
long long ret = 0;
while (x > 0) {
ret++;
x /= 10;
}
return ret;
}
int main() {
pw[0] = 1;
for (int i = 1; i <= 25; i++) pw[i] = pw[i - 1] * 10 % MOD;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
num[di(a[i])]++;
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 10; j++) {
int x, now = a[i], ndn = 0;
while (now > 0) {
x = now % 10;
now /= 10;
if (j >= ndn + 1)
ans = (ans + (pw[ndn * 2] + pw[ndn * 2 + 1]) * x * num[j]) % MOD;
else
ans = (ans + pw[ndn + j] * x * num[j] * 2) % MOD;
ndn++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = (int)1e6 + 5, p = 998244353;
int A[MAX], len[MAX], dig[13];
int e10[] = {1, 10, 100, 1000, 10000,
100000, 1000000, 10000000, 100000000, 1755647,
17556470, 175564700, 757402647, 586315999, 871938225,
733427426, 346563789, 470904831, 716070898, 172998509};
int main() {
int n;
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
for (int i = 0; i < 13; i++) dig[i] = 0;
int gg = 0;
for (int i = 0; i < n; i++) {
int x = A[i], count = 0;
while (x > 0) {
int add = (x % 10ll) * (e10[2 * count] + e10[2 * count + 1]) % p;
gg = (gg + add) % p;
x /= 10;
count++;
}
len[i] = count;
dig[count]++;
}
for (int i = 10; i >= 0; i--) dig[i] += dig[i + 1];
for (int i = 0; i < n; i++) {
int x = A[i], count = 1, ex = 1;
while (x > 0) {
int add = (x % 10ll) * (dig[count] - 1ll) * e10[ex] % p;
gg = (gg + add) % p;
add = (x % 10ll) * (dig[count - 1] - 1ll) * e10[ex - 1] % p;
gg = (gg + add) % p;
for (int j = 1; j < count; j++) {
add = (x % 10ll) * (dig[j] - dig[j + 1]) * e10[count + j - 1] % p;
if (j < count - 1) add = (add + add) % p;
gg = (gg + add) % p;
}
x /= 10;
count++;
ex += 2;
}
}
printf("%d\n", gg);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long int maxn = 5e5 + 1;
void solve() {
long long int n;
cin >> n;
long long int a[n], len[11];
memset(len, 0, sizeof(len));
for (long long int i = 0; i < n; i++) {
cin >> a[i];
long long int d = a[i];
long long int k = 0;
while (d) {
d /= 10;
k++;
}
len[k]++;
}
long long int power[30];
power[0] = 1;
for (long long int i = 1; i < 30; i++) {
power[i] = power[i - 1] * 10;
power[i] %= (long long int)(998244353);
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
long long int d = a[i];
long long int k = 0;
vector<long long int> v;
while (d) {
long long int r = d % 10;
d /= 10;
k++;
for (long long int l = 1; l <= 10; l++) {
if (l >= k) {
long long int aa = power[2 * k - 1];
aa *= r;
aa %= (long long int)(998244353);
aa *= len[l];
aa %= (long long int)(998244353);
ans += aa;
ans %= (long long int)(998244353);
} else {
long long int aa = power[l + k - 1];
aa *= len[l];
aa %= (long long int)(998244353);
aa *= r;
aa %= (long long int)(998244353);
ans += aa;
ans %= (long long int)(998244353);
}
if (l >= k - 1) {
long long int aa = power[2 * (k - 1)];
aa *= len[l];
aa %= (long long int)(998244353);
aa *= r;
aa %= (long long int)(998244353);
ans += aa;
ans %= (long long int)(998244353);
} else {
long long int aa = power[l + k - 1];
aa *= len[l];
aa %= (long long int)(998244353);
aa *= r;
aa %= (long long int)(998244353);
ans += aa;
ans %= (long long int)(998244353);
}
}
}
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
using namespace std;
long long expo(long long base, long long exponent, long long mod) {
long long ans = 1;
while (exponent != 0) {
if ((exponent & 1) == 1) {
ans = ans * base;
ans = ans % mod;
}
base = base * base;
base %= mod;
exponent >>= 1;
}
return ans % mod;
}
long long add(long long a, long long b) {
return (a % 998244353 + b % 998244353) % 998244353;
}
long long sub(long long a, long long b) {
return (a % 998244353 - b % 998244353 + 998244353) % 998244353;
}
long long mul(long long a, long long b) {
return ((a % 998244353) * (b % 998244353)) % 998244353;
}
long long inverse(long long n, long long p) { return expo(n, p - 2, p); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, n, m, k, cnt = 0, ans = 0, t = 1;
long long ten[25] = {0};
cin >> n;
for (i = 0; i < 25; i++) ten[i] = expo(10, i, 998244353);
long long d[11] = {0};
vector<string> v(n);
for (i = 0; i < n; i++) {
cin >> v[i];
d[v[i].length()]++;
}
for (i = 0; i < n; i++) {
k = v[i].length();
string s = v[i];
for (j = 1; j < 11; j++) {
long long val = 0, l;
cnt = 0;
for (l = s.length() - 1; l >= max(0LL, k - 1 - j); l--)
val = add(val, mul((s[l] - '0'), ten[cnt])), cnt += 2;
cnt--;
while (l >= 0) val = add(val, mul((s[l] - '0'), ten[cnt])), cnt++, l--;
ans = add(ans, mul(val, d[j]));
val = 0, cnt = 1;
for (l = s.length() - 1; l >= max(0LL, k - j); l--)
val = add(val, mul((s[l] - '0'), ten[cnt])), cnt += 2;
cnt--;
while (l >= 0) val = add(val, mul((s[l] - '0'), ten[cnt])), cnt++, l--;
ans = add(ans, mul(val, d[j]));
}
}
return cout << ans, 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> getdig(int x) {
vector<int> ans;
while (x) {
ans.push_back(x % 10);
x /= 10;
}
return ans;
}
int main() {
vector<long long> p10(30);
p10[0] = 1;
for (int i = 1; i < p10.size(); i++) p10[i] = (p10[i - 1] * 10) % 998244353;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n), cnt(20);
vector<vector<int>> dig(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
dig[i] = getdig(a[i]);
cnt[dig[i].size()]++;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < dig[i].size(); j++) {
int rest = n;
for (int k = 0; k < j; k++) {
rest -= cnt[k];
ans += p10[j + k] * (dig[i][j] * cnt[k]) % 998244353;
ans %= 998244353;
}
ans += p10[2 * j] * (dig[i][j] * rest) % 998244353;
ans %= 998244353;
rest = n;
for (int k = 0; k <= j; k++) {
rest -= cnt[k];
ans += p10[j + k] * (dig[i][j] * cnt[k]) % 998244353;
ans %= 998244353;
}
ans += p10[2 * j + 1] * (dig[i][j] * rest) % 998244353;
ans %= 998244353;
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long pre[100005][11], nxt[100005][11], a[100005];
int cnt[11];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
long long t = a[i], k = 0;
while (t) {
t /= 10;
k++;
}
cnt[k]++;
pre[i][1] = a[i] * 10;
nxt[i][1] = (a[i] - a[i] % 10) * 10 + a[i] % 10;
long long now = 100;
for (int j = 2; j <= 9; j++) {
pre[i][j] =
(pre[i][j - 1] - pre[i][j - 1] % now) * 10 + pre[i][j - 1] % now;
now *= 100;
}
pre[i][10] =
(pre[i][9] - pre[i][9] % now) % 998244353 * 10 + pre[i][9] % now;
for (int j = 1; j <= 10; j++) pre[i][j] %= 998244353;
now = 1000;
for (int j = 2; j <= 10; j++) {
nxt[i][j] =
(nxt[i][j - 1] - nxt[i][j - 1] % now) * 10 + nxt[i][j - 1] % now;
now *= 100;
}
nxt[i][10] =
(nxt[i][9] - nxt[i][9] % now) % 998244353 * 10 + nxt[i][9] % now;
for (int j = 1; j <= 10; j++) nxt[i][j] %= 998244353;
}
long long ans = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 10; j++) {
ans += (pre[i][j] + nxt[i][j]) * cnt[j];
ans %= 998244353;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fast(long long int n, long long int a, long long int m) {
if (n == 0)
return 1;
else if (n == 1)
return a;
else {
long long int r = fast(n / 2, a, m);
if (n % 2 == 0) {
return (((r % m) * (r % m)) % m);
} else {
return (((((r % m) * a) % m) * r) % m);
}
}
}
long long int po2[23];
long long int len(long long int n) {
long long int p = 0;
while (n > 0) {
p++;
n /= 10;
}
return p;
}
int main() {
po2[0] = 1;
for (long long int i = 1; i <= 22; i++) {
po2[i] = ((po2[i - 1] % 998244353) * (10 % 998244353)) % 998244353;
}
long long int n, i, j, k;
cin >> n;
long long int A[n], d[12] = {0};
for (i = 0; i < n; i++) {
cin >> A[i];
d[len(A[i])]++;
}
long long int ans = 0;
for (i = 0; i < n; i++) {
vector<long long int> dp;
long long int res = A[i];
while (res > 0) {
dp.push_back(res % 10);
res /= 10;
}
long long int lenr = dp.size();
reverse(dp.begin(), dp.end());
for (j = 1; j <= lenr; j++) {
long long int r = 0, g;
for (k = 1; k <= lenr - j + 1; k++) {
g = ((dp[k - 1] % 998244353) * (po2[lenr + j - k] % 998244353)) %
998244353;
r = (r % 998244353 + g % 998244353) % 998244353;
}
long long int f = 1;
for (k = lenr; k >= lenr - j + 2; k--) {
g = ((dp[k - 1] % 998244353) * (po2[f] % 998244353)) % 998244353;
r = (r % 998244353 + g % 998244353) % 998244353;
f += 2;
}
long long int tot = ((d[j] % 998244353) * (r % 998244353)) % 998244353;
ans = (ans % 998244353 + tot % 998244353) % 998244353;
}
for (j = lenr + 1; j <= 10; j++) {
long long int r = 0, f = 1, g;
for (k = lenr; k >= 1; k--) {
g = ((dp[k - 1] % 998244353) * (po2[f] % 998244353)) % 998244353;
r = (r % 998244353 + g % 998244353) % 998244353;
f += 2;
}
long long int tot = (d[j] * r) % 998244353;
ans = (ans % 998244353 + tot % 998244353) % 998244353;
}
}
for (i = 0; i < n; i++) {
vector<long long int> dp;
long long int res = A[i];
while (res > 0) {
dp.push_back(res % 10);
res /= 10;
}
long long int lenp = dp.size();
reverse(dp.begin(), dp.end());
for (j = lenp; j <= 10; j++) {
long long int r = 0, g = 0;
for (k = lenp; k >= 1; k--) {
long long int d =
((dp[k - 1] % 998244353) * (po2[g] % 998244353)) % 998244353;
r = (r % 998244353 + d % 998244353) % 998244353;
g += 2;
}
long long int tot = ((d[j] % 998244353) * (r % 998244353)) % 998244353;
ans = (ans % 998244353 + tot % 998244353) % 998244353;
}
for (j = 1; j < lenp; j++) {
long long int r = 0, g;
for (k = 1; k <= lenp - j; k++) {
g = ((dp[k - 1] % 998244353) * (po2[lenp + j - k] % 998244353)) %
998244353;
r = (r % 998244353 + g % 998244353) % 998244353;
}
long long int f = 0;
for (k = lenp; k >= lenp - j + 1; k--) {
g = ((dp[k - 1] % 998244353) * (po2[f] % 998244353)) % 998244353;
r = (r % 998244353 + g % 998244353) % 998244353;
f += 2;
}
long long int tot = ((d[j] % 998244353) * (r % 998244353)) % 998244353;
ans = (ans % 998244353 + tot % 998244353) % 998244353;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 5;
const long long Inf = 2e9;
const long long mod = 998244353;
int n, mx;
int cnt[20];
long long pos[50];
vector<string> v;
void add(string s) {
for (int l = s.length(); l <= 10; l++) {
int align = 2 * mx - (l + s.length());
int offset = l - s.length();
for (int i = 0; i < s.length(); i++) {
pos[offset + align + 2 * i + 1] += 1ll * (s[i] - '0') * cnt[l];
pos[offset + align + 2 * i + 1] %= mod;
pos[offset + align + 2 * i + 2] += 1ll * (s[i] - '0') * cnt[l];
pos[offset + align + 2 * i + 2] %= mod;
}
}
for (int l = 1; l < s.length(); l++) {
int align = 2 * mx - (l + s.length());
int offset = s.length() - l;
for (int i = 0; i < offset; i++) {
pos[1 + i + align] += 2ll * (s[i] - '0') * cnt[l];
pos[1 + i + align] %= mod;
}
for (int i = offset; i < s.length(); i++) {
pos[2 * (i - offset) + offset + 1 + align] += 1ll * (s[i] - '0') * cnt[l];
pos[2 * (i - offset) + offset + 1 + align] %= mod;
pos[2 * (i - offset) + offset + 2 + align] += 1ll * (s[i] - '0') * cnt[l];
pos[2 * (i - offset) + offset + 2 + align] %= mod;
}
}
}
int main() {
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
v.push_back(s);
cnt[s.length()]++;
mx = max(mx, (int)s.length());
}
for (int i = 0; i < v.size(); i++) add(v[i]);
long long ans = 0;
for (int i = 1; i <= mx * 2; i++) {
ans *= 10;
ans %= mod;
ans += pos[i];
ans %= mod;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const long long mod = 998244353;
int a[N];
int vis[20], n;
long long sum[20];
long long powmod(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int cal(int x) {
int res = 0;
while (x) {
x /= 10;
res++;
}
return res;
}
long long go(int x) {
long long res = 0;
stack<long long> q1, q2, q3;
while (x) {
long long d = x % 10;
x /= 10;
q1.push(d);
}
long long d = 0;
q3.push(0);
while (q1.size()) {
d++;
q2.push(q1.top());
q3.push((q3.top() * 10 % mod + 2 * q1.top() % mod) % mod);
q1.pop();
}
q3.pop();
d = 1;
long long tmp = 0;
while (q2.size() > 1) {
long long d1 = q2.top();
long long d2 = q3.top();
d1 = (d1 * 10 % mod + d1) % mod * powmod(100, d - 1) % mod + tmp;
d1 %= mod;
d2 = d2 * powmod(100, d) % mod;
d2 %= mod;
tmp = d1;
res = (res + (d1 + d2) * vis[d] % mod) % mod;
q2.pop();
q3.pop();
d++;
}
long long d1 = q2.top();
long long d2 = q3.top();
d1 = (d1 * 10 % mod + d1) % mod * powmod(100, d - 1) % mod + tmp;
d1 %= mod;
d2 = d2 * powmod(100, d) % mod;
d2 %= mod;
tmp = d1;
res = (res + (d1 + d2) * sum[d] % mod) % mod;
q2.pop();
q3.pop();
d++;
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
vis[cal(a[i])]++;
}
int j = 0;
sort(a + 1, a + 1 + n);
long long ans = 0;
sum[10] = vis[10];
for (int i = 9; i >= 1; --i) {
sum[i] = (sum[i + 1] + vis[i]) % mod;
}
j = 0;
for (int i = 1; i <= n; ++i) {
ans = (ans + go(a[i])) % mod;
}
printf("%lld\n", ans % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dx[] = {1, -1, 0, 0};
long long int dy[] = {0, 0, -1, 1};
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int power_mod(long long int a, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1)
res = ((res % 998244353) * (a % 998244353)) % 998244353, n--;
else
a = ((a % 998244353) * (a % 998244353)) % 998244353, n /= 2;
}
return res;
}
long long int nCr(long long int n, long long int r) {
if (r > n) return 0;
double res = 1;
for (long long int i = 1; i <= r; i++) res = (res * (n - r + i)) / i;
return (long long int)(res + 0.01);
}
long long int power(long long int a, long long int n) {
long long int res = 1;
for (long long int i = 0; i < n; i++) res = res * a;
return res;
}
bool cmp(vector<long long int> a, vector<long long int> b) {
return a[0] < b[0];
}
bool is_power_of_two(long long int n) {
for (long long int i = 0; i < 32; i++) {
if ((1 << i) == n) return true;
}
return false;
}
long long int len(long long int n) {
string s = to_string(n);
return s.size();
}
void solve() {
long long int p[21];
for (long long int i = 0; i < 20; i++) {
p[i] = power_mod(10, i) % 998244353;
}
long long int n;
cin >> n;
long long int a[n];
long long int dp[11];
for (long long int i = 0; i < 11; i++) dp[i] = 0;
for (long long int i = 0; i < n; i++) cin >> a[i], dp[len(a[i])]++;
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
string s = to_string(a[i]);
long long int cnt = 0;
for (long long int j = s.size() - 1; j >= 0; j--) {
ans = (ans % 998244353 + ((s[j] - '0') * p[cnt]) % 998244353) % 998244353;
cnt += 2;
}
cnt = 1;
for (long long int j = s.size() - 1; j >= 0; j--) {
ans = (ans % 998244353 + ((s[j] - '0') * p[cnt]) % 998244353) % 998244353;
cnt += 2;
}
}
for (long long int i = 0; i < n; i++) {
string s = to_string(a[i]);
long long int l = s.size();
dp[l]--;
for (long long int j = 1; j < 11; j++) {
long long int temp = 0;
long long int cnt = 0;
long long int cn = 0;
for (long long int k = l - 1; k >= 0; k--) {
temp = (temp % 998244353 + ((s[k] - '0') * p[cnt]) % 998244353) %
998244353;
cn++;
if (cn < j + 1)
cnt += 2;
else
cnt++;
}
ans = (ans % 998244353 +
((temp % 998244353) * (dp[j] % 998244353)) % 998244353) %
998244353;
temp = 0;
cnt = 1;
cn = 0;
for (long long int k = l - 1; k >= 0; k--) {
temp = (temp % 998244353 + ((s[k] - '0') * p[cnt]) % 998244353) %
998244353;
cn++;
if (cn < j)
cnt += 2;
else
cnt++;
}
ans = (ans % 998244353 +
((temp % 998244353) * (dp[j] % 998244353)) % 998244353) %
998244353;
}
dp[l]++;
}
cout << ans % 998244353;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
string ar[100005];
long long mod = 998244353;
long long F(string &x) {
long long val = 0;
for (int i = 0; i < x.size(); i++) {
val *= 10;
val %= mod;
val += (x[i] - '0');
val %= mod;
}
return val % mod;
}
long long L[15];
int main() {
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ar[i];
L[(long long)ar[i].size()]++;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int len = 0; len < 11; len++) {
string tmpr = "";
string tmp = ar[i];
reverse(tmp.begin(), tmp.end());
int tt = len;
for (int j = 0; j < tmp.size(); j++) {
tmpr += tmp[j];
if (tt > 0) {
tmpr += '0';
tt--;
}
}
tt = len;
string tmpl = "";
for (int j = 0; j < tmp.size(); j++) {
if (tt > 0) {
tt--;
tmpl += '0';
}
tmpl += tmp[j];
}
reverse(tmpl.begin(), tmpl.end());
reverse(tmpr.begin(), tmpr.end());
long long val1 = F(tmpl);
long long val2 = F(tmpr);
long long ttt = ((val1 % mod) * (L[len] % mod)) % mod;
long long ppp = ((val2 % mod) * (L[len] % mod)) % mod;
ttt = ((ttt % mod) + (ppp % mod)) % mod;
ans = ((ans % mod) + (ttt % mod)) % mod;
}
}
cout << ans % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
const long long MOD = 998244353;
long long n, cnt[20], a[N];
long long p10[20];
long long scs(long long x) {
long long res = 0;
while (x) {
res++;
x /= 10;
}
return res;
}
long long calc(long long x) {
long long res = 0;
long long nDi = scs(x);
for (long long i = 1; i <= nDi; i++) {
long long u = x % 10;
x /= 10;
for (long long j = 1; j <= 20; j++) {
long long dem = 0;
{
long long v = j - i;
if (v >= 0 && v == i - 1) {
for (long long k = v; k <= 10; k++) {
dem += cnt[k];
}
} else if (v >= 0 && v < i - 1) {
dem += cnt[v];
}
}
{
long long v = j - i;
if (v >= 0 && v == i) {
for (long long k = v; k <= 10; k++) {
dem += cnt[k];
}
} else if (v >= 0 && v < i) {
dem += cnt[v];
}
}
res = (res + 1LL * u * dem * p10[j - 1]) % MOD;
}
}
return res;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
p10[0] = 1;
for (long long i = 1; i < 20; i++) {
p10[i] = (p10[i - 1] * 10) % MOD;
}
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
cnt[scs(a[i])]++;
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
ans = (ans + calc(a[i])) % MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long b, long long c) {
long long t = 1;
while (b) {
if (b & 1) t = t * a % c;
a = a * a % c;
b >>= 1;
}
return t;
}
int test = 1;
const int maxn = 5 + 1e5;
const int maxm = 5 + 1e5;
long long n;
long long ar[maxn];
int len[maxn];
long long cnt[20];
long long f[22];
int main() {
f[0] = 1;
for (int i = 1; i <= 20; i++) {
f[i] = f[i - 1] * 10 % mod;
}
while (test--) {
cin >> n;
long long t;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
len[i] = 0;
t = ar[i];
while (t) {
len[i]++;
t /= 10;
}
cnt[len[i]]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
t = ar[i];
for (int j = 1; j <= len[i]; j++) {
for (int k = 1; k <= 10; k++) {
if (k < j)
ans = (ans + (t % 10) * 2 * f[j - 1 + k] * cnt[k]) % mod;
else
ans = (ans +
(f[2 * j - 2] + f[2 * j - 1]) % mod * (t % 10) * cnt[k]) %
mod;
}
t /= 10;
}
}
cout << ans % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const INF = (int)1e9 + 1e3;
long long const INFL = (long long)1e18 + 1e6;
mt19937 tw(chrono::high_resolution_clock::now().time_since_epoch().count());
uniform_int_distribution<long long> ll_distr;
long long rnd(long long a, long long b) {
return ll_distr(tw) % (b - a + 1) + a;
}
const int MOD = 998244353;
void add(int& a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
}
int sum(int a, int b) {
add(a, b);
return a;
}
int mult(int a, int b) { return (long long)a * b % MOD; }
int f(vector<int> const& a, int l) {
int res = 0;
int p = 1;
for (int i = 0; i < max(((int)a.size()), l); ++i) {
if (i < l) {
p = mult(p, 10);
}
if (i < ((int)a.size())) {
add(res, mult(a[i], p));
p = mult(p, 10);
}
}
return res;
}
int f(int l, vector<int> const& b) {
int res = 0;
int p = 1;
for (int i = 0; i < max(l, ((int)b.size())); ++i) {
if (i < ((int)b.size())) {
add(res, mult(b[i], p));
p = mult(p, 10);
}
if (i < l) {
p = mult(p, 10);
}
}
return res;
}
void solve() {
int n;
cin >> n;
vector<int> arr;
const int MAXL = 11;
vector<int> of_len(MAXL);
for (int i = 0; i < n; ++i) {
int num;
cin >> num;
arr.push_back(num);
int l = 0;
int tmp = num;
while (tmp) {
++l;
tmp /= 10;
}
of_len[l]++;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
vector<int> digits;
int tmp = arr[i];
while (tmp) {
digits.push_back(tmp % 10);
tmp /= 10;
}
for (int l = 1; l < MAXL; ++l) {
int sum = f(digits, l);
add(ans, mult(sum, of_len[l]));
sum = f(l, digits);
add(ans, mult(sum, of_len[l]));
}
}
cout << ans << "\n";
}
int main() {
cout << setprecision(15) << fixed;
ios::sync_with_stdio(false);
cin.tie(nullptr);
int test_count = 1;
for (int test = 1; test <= test_count; ++test) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long pow_mod(long long x, long long y) {
long long r = 1;
for (; y; y >>= 1, x = (long long)x * x % 998244353)
if (y & 1) r = (long long)r * x % 998244353;
return r;
}
int cal(long long x) {
int ans = 0;
while (x) {
ans++;
x /= 10;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int mp[20];
memset(mp, 0, sizeof(mp));
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
int cnt = cal(a[i]);
mp[cnt]++;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long x;
for (int j = 1; j <= 10; j++) {
x = a[i];
long long val = 1;
int k = j;
while (x) {
ans = (ans + (mp[j] * val % 998244353) * (x % 10) % 998244353) %
998244353;
x /= 10;
val = (val * 10ll) % 998244353;
if (k) {
k--;
val = (val * 10ll) % 998244353;
}
}
}
for (int j = 1; j <= 10; j++) {
x = a[i];
long long val = 1;
int k = j;
while (x) {
if (k) {
k--;
val = (val * 10ll) % 998244353;
}
ans = (ans + (mp[j] * val % 998244353) * (x % 10) % 998244353) %
998244353;
x /= 10;
val = (val * 10ll) % 998244353;
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long n, a[100001], sum[11], tsum[11], tp, p10[21], ans;
int main() {
p10[0] = 1;
scanf("%lld", &n);
for (long long i = 1, t; i <= n; i++) {
scanf("%lld", &a[i]);
t = 0;
for (long long tp = 1; tp <= a[i]; tp *= 10) t++;
sum[t]++;
tsum[t]++;
}
for (int i = 1; i <= 20; i++) {
p10[i] = p10[i - 1] * 10;
if (i <= 10) {
sum[i] += sum[i - 1];
tsum[i] = (p10[i] * tsum[i] + tsum[i - 1]) % mod;
} else
p10[i] %= mod;
}
for (long long i = 1, t; i <= n; i++) {
for (int j = 0; j <= 9; j++) {
t = a[i] % p10[j + 1] / p10[j];
ans = (ans +
t * ((2 * p10[j] * tsum[j] + (n - sum[j]) * p10[2 * j] * 11))) %
mod;
}
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long longinf = 1LL << 60;
const long long mod = 998244353;
const long double eps = 1e-10;
template <typename T1, typename T2>
inline void chmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &a, T2 b) {
if (a < b) a = b;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<long long> A(n);
for (int i = (int)(0); i < (int)(n); i++) cin >> A[i];
vector<int> id(n);
iota(id.begin(), id.end(), 0);
sort(id.begin(), id.end(),
[&](int i, int j) { return log10(A[i]) < log10(A[j]); });
int d = 15;
vector<long long> pw(2 * d + 1);
pw[0] = 1;
for (int i = (int)(0); i < (int)(2 * d + 1); i++)
if (i) pw[i] = pw[i - 1] * 10 % mod;
long long ans = 0;
vector<int> cnt(d + 1);
for (int i : id) {
int rem = n;
long long a = A[i];
long long sum = 0;
for (int j = (int)(0); j < (int)(log10(A[i]) + 1); j++) {
(sum += (a % 10) * pw[2 * j]) %= mod;
a /= 10;
(ans += (sum * 11 + a * pw[2 * (j + 1)] * 2) * cnt[j + 1] % mod) %= mod;
rem -= cnt[j + 1];
}
(ans += (sum * 11) * rem % mod) %= mod;
cnt[log10(A[i]) + 1]++;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string second[100005], temp;
int sz[15];
long long ten[25];
void concatanation(string p, string q) {
int cnt = 0;
while (p.size() || q.size()) {
if (p.empty()) {
temp += q.back();
q.pop_back();
} else if (q.empty()) {
temp += p.back();
p.pop_back();
} else {
if (cnt % 2 == 0) {
temp += q.back();
q.pop_back();
} else {
temp += p.back();
p.pop_back();
}
}
cnt++;
}
}
long long age(int a, int b) {
string p = second[a];
string q;
for (int i = 0; i < b; i++) q += '0';
temp.clear();
concatanation(p, q);
long long ret = 0;
for (int i = 0; i < temp.size(); i++) {
long long mul = (((temp[i] - '0') * ten[i]) % 998244353) * sz[b];
mul %= 998244353;
ret = (ret + mul) % 998244353;
}
return ret;
}
long long pore(int a, int b) {
string p = second[a];
string q;
for (int i = 0; i < b; i++) q += '0';
temp.clear();
concatanation(q, p);
long long ret = 0;
for (int i = 0; i < temp.size(); i++) {
long long mul = (((temp[i] - '0') * ten[i]) % 998244353) * sz[b];
mul %= 998244353;
ret = (ret + mul) % 998244353;
}
return ret;
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
ten[0] = 1;
for (int i = 1; i <= 20; i++) ten[i] = (ten[i - 1] * 10) % 998244353;
cin >> n;
for (int i = 0; i < n; i++) cin >> second[i];
for (int i = 0; i < n; i++) sz[second[i].size()]++;
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 10; j++) {
ans = (ans + age(i, j)) % 998244353;
ans = (ans + pore(i, j)) % 998244353;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
const int mod = 998244353;
long long a[N];
int cnt[20];
long long pw[30];
void init() {
pw[0] = 1;
for (int i = 1; i <= 29; i++) pw[i] = (pw[i - 1] % mod * 10 % mod) % mod;
}
int siz[N];
int main() {
int n;
cin >> n;
init();
for (int i = 1; i <= n; i++) {
cin >> a[i];
long long x = a[i];
while (x) {
siz[i]++;
x /= 10;
}
cnt[siz[i]]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long x = a[i];
int p = 0;
while (x) {
int c = x % 10;
x /= 10;
p++;
for (int j = 1; j <= 10; j++) {
if (j <= p) {
ans += (c % mod * cnt[j] % mod * pw[p + j - 1] % mod) % mod;
ans % mod;
} else {
ans += (c % mod * cnt[j] % mod * pw[2 * p - 1] % mod) % mod;
ans % mod;
}
if (j < p) {
ans += (c % mod * cnt[j] % mod * pw[p + j - 1] % mod) % mod;
ans %= mod;
} else {
ans += (c % mod * cnt[j] % mod * pw[2 * (p - 1)] % mod) % mod;
ans % mod;
}
}
}
}
cout << ans % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MNOGO = 2e9;
const long long MD = 998244353;
const double EPS = 1e-7;
struct pryama {
double a, b, c;
};
class segmentTree {
public:
long long val = 0;
segmentTree* left = nullptr;
segmentTree* right = nullptr;
long long tl = 0, tr = 1ll << 22;
void createSons() {
if (left == nullptr) {
left = new segmentTree();
left->tl = tl;
left->tr = (tl + tr) / 2;
}
if (right == nullptr) {
right = new segmentTree();
right->tr = tr;
right->tl = (tl + tr) / 2 + 1;
}
}
void update(long long pos, long long q) {
if (tl == tr) {
val += q;
return;
}
long long tm = (tl + tr) / 2;
createSons();
if (pos <= tm) {
left->update(pos, q);
} else {
right->update(pos, q);
}
val = left->val + right->val;
}
long long get(long long l, long long r) {
if (l > r) {
return 0;
}
if (l > tr || r < tl) {
return 0;
}
if (tl >= l && tr <= r) {
return val;
}
createSons();
return left->get(l, r) + right->get(l, r);
}
};
long long n;
long long ans[10];
string a[100005];
long long dl1[15], dl2[15];
long long cnt[15], cdl2[15];
long long sqr(long long a) { return a * a; }
long long binpow(long long a, long long b) {
if (b == 0) {
return 1;
}
if (b % 2 == 0) {
return sqr(binpow(a, b / 2)) % MD;
}
return a * binpow(a, b - 1) % MD;
}
long long modify(string& st, long long type, long long sz) {
long long wsz = sz;
if (type == 1) {
string res;
long long rz = 0, curSz = 0;
for (long long j = st.size() - 1; j >= 0; j--, sz--) {
rz += (binpow(10, curSz) * (st[j] - '0')) % MD;
rz %= MD;
curSz++;
if (sz > 0) {
curSz++;
}
}
return rz % MD;
} else {
string res;
long long rz = 0, curSz = 0;
for (long long j = st.size() - 1; j >= 0; j--, sz--) {
if (sz > 0) {
curSz++;
}
rz += (binpow(10, curSz) * (st[j] - '0')) % MD;
rz %= MD;
curSz++;
}
return rz % MD;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
string st2(a[i].size() * 2, '0');
long long indx = a[i].size() - 1;
long long curSz = 0, curNum = 0;
for (long long j = st2.size() - 1; j >= 0; j -= 2) {
curNum += (binpow(10, curSz) * (a[i][indx--] - '0')) % MD;
curNum %= MD;
curSz += 2;
}
dl1[a[i].size()] += curNum;
dl1[a[i].size()] %= MD;
st2.assign(a[i].size() * 2, '0');
indx = a[i].size() - 1;
curNum = 0;
if (a[i].size() != 10) {
long long curSz = 1;
for (long long j = (long long)st2.size() - 2; j >= 0; j -= 2) {
curNum += (binpow(10, curSz) * (a[i][indx--] - '0')) % MD;
curNum %= MD;
curSz += 2;
}
dl2[a[i].size()] += curNum;
dl2[a[i].size()] %= MD;
}
cnt[a[i].size()]++;
}
for (long long i = 1; i <= n; i++) {
string st = a[i];
for (long long d = 1; d <= st.size(); d++) {
ans = (ans + dl1[d]) % MD;
ans = (ans + (cnt[d] * modify(a[i], 2, d)) % MD) % MD;
}
for (long long d = 1; d < st.size(); d++) {
ans = (ans + dl2[d]) % MD;
ans = (ans + (cnt[d] * modify(a[i], 1, d)) % MD) % MD;
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 998244353LL;
const int N_MAX = 1e5 + 15;
int A[N_MAX];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
long long ans = 0LL;
bool rem = 1;
long long q = 1LL, w = 0LL;
long long v = n * 1LL;
while (v) {
long long t = 0LL;
for (int i = 0; i < n; i++) {
if (A[i] == -1) continue;
if (A[i] == 0) {
w += (2LL * q);
w %= P;
v -= 1LL;
A[i] = -1;
} else {
t += (1LL * (A[i] % 10));
A[i] /= 10;
}
}
if (v == 0) break;
long long m = 0LL;
m += v;
m *= q;
m %= P;
m *= 11LL;
m %= P;
m += w;
m %= P;
t *= m;
t %= P;
q *= 100LL;
q %= P;
ans += t;
ans %= P;
w *= 10LL;
w %= P;
}
ans %= P;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t[100009];
long long db[11];
long long jegyek[100009];
long long h10[25];
long long MOD = 998244353;
int n;
long long ans = 0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
h10[0] = 1;
for (int i = 1; i <= 21; i++) {
h10[i] = (h10[i - 1] * 10ll) % MOD;
}
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t[i];
long long p10 = 1;
for (int j = 1; j <= 10; j++) {
p10 *= 10ll;
if (p10 > t[i]) {
jegyek[i] = j;
db[j]++;
break;
}
}
}
for (int i = 1; i <= n; i++) {
long long w = t[i];
for (int j = 1; j <= 10; j++) {
long long jegy = w % 10;
w /= 10;
if (jegy == 0) continue;
for (int k = 1; k <= 10; k++) {
if (k >= j) {
ans = (ans + (long long)db[k] * jegy * h10[2 * j - 2]) % MOD;
} else {
ans = (ans + (long long)db[k] * jegy * h10[j + k - 1]) % MOD;
}
if (k >= j) {
ans = (ans + (long long)db[k] * jegy * h10[2 * j - 1]) % MOD;
} else {
ans = (ans + (long long)db[k] * jegy * h10[j + k - 1]) % MOD;
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mul(long long a, long long b) {
return ((a % 998244353) * (b % 998244353)) % 998244353;
}
long long add(long long a, long long b) {
return ((a % 998244353) + (b % 998244353)) % 998244353;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
cin >> a[i];
long long temp = a[0];
long long l = 0, mal = 0;
vector<long long> lel(n);
map<long long, long long> lc;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
l = 0;
temp = a[i];
while (temp) {
l++;
temp /= 10;
}
lc[l]++;
mal = max(mal, l);
lel[i] = l;
}
vector<long long> p(2 * mal);
p[0] = 1;
for (__typeof(p.size()) i = (1) - ((1) > (p.size()));
i != (p.size()) - ((1) > (p.size())); i += 1 - 2 * ((1) > (p.size())))
p[i] = mul(p[i - 1], 10);
long long ans = 0;
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n))) {
temp = a[i];
vector<long long> k(lel[i]);
k[0] = a[i];
for (__typeof(lel[i]) j = (1) - ((1) > (lel[i]));
j != (lel[i]) - ((1) > (lel[i])); j += 1 - 2 * ((1) > (lel[i]))) {
k[j] = 0;
temp = a[i];
l = 0;
while (temp) {
l++;
if (l <= (j + 1))
k[j] = add(k[j], mul(temp % 10, p[(2 * (l - 1))]));
else
k[j] = add(k[j], mul(temp % 10, p[(l + j - 1)]));
temp /= 10;
}
}
for (__typeof(12) o = (1) - ((1) > (12)); o != (12) - ((1) > (12));
o += 1 - 2 * ((1) > (12))) {
if (o >= lel[i])
ans = add(ans, add(mul(k[lel[i] - 1], lc[o]),
mul(lc[o], mul(10, k[lel[i] - 1]))));
else
ans = add(ans, add(mul(k[o], lc[o]), mul(lc[o], mul(10, k[o - 1]))));
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline void read(T& x) {
x = 0;
T fg = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') fg = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x = fg * x;
}
template <typename T, typename... Args>
inline void read(T& x, Args&... args) {
read(x), read(args...);
}
template <typename T>
inline void write(T x) {
int len = 0;
char c[21];
if (x < 0) putchar('-'), x = -x;
do {
++len;
c[len] = x % 10 + '0';
} while (x /= 10);
for (int i = len; i >= 1; i--) putchar(c[i]);
}
template <typename T, typename... Args>
inline void write(T x, Args... args) {
write(x), write(args...);
}
inline int add(int a, int b) {
long long res = ((long long)a + b) % 998244353;
if (res < 0) res += 998244353;
return res;
}
inline int mul(int a, int b) { return (int)((long long)a * b % 998244353); }
long long a[100005];
long long cnt[100005], sumcnt[12];
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) read(a[i]);
memset(sumcnt, 0, sizeof sumcnt);
for (int i = 1; i <= n; i++) {
long long x = a[i];
cnt[i] = 0;
while (x) {
x /= 10;
cnt[i]++;
}
sumcnt[cnt[i]]++;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int x, tmp, cntx, xishu;
for (int cnty = 1; cnty < 12; cnty++) {
x = a[i];
tmp = 0;
cntx = 0, xishu = 1;
while (x) {
tmp = add(tmp, mul(xishu, x % 10));
cntx++;
if (cntx <= cnty) xishu = mul(xishu, 10);
xishu = mul(xishu, 10);
x /= 10;
}
x = a[i];
cntx = 0, xishu = 1;
while (x) {
if (cntx < cnty) xishu = mul(xishu, 10);
tmp = add(tmp, mul(xishu, x % 10));
cntx++;
xishu = mul(xishu, 10);
x /= 10;
}
ans = add(ans, mul(sumcnt[cnty], tmp));
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = (int)1e6 + 5, p = 998244353;
int A[MAX], len[MAX], dig[13];
int e10[] = {1, 10, 100, 1000, 10000,
100000, 1000000, 10000000, 100000000, 1755647,
17556470, 175564700, 757402647, 586315999, 871938225,
733427426, 346563789, 470904831, 716070898, 172998509};
int main() {
int n;
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
for (int i = 0; i < 13; i++) dig[i] = 0;
int gg = 0;
for (int i = 0; i < n; i++) {
int x = A[i], count = 0;
while (x > 0) {
int add = (x % 10ll) * (e10[2 * count] + e10[2 * count + 1]) % p;
gg = (gg + add) % p;
x /= 10;
count++;
}
len[i] = count;
dig[count]++;
}
for (int i = 10; i >= 0; i--) dig[i] += dig[i + 1];
for (int i = 0; i < n; i++) {
int x = A[i], count = 1, ex = 1;
while (x > 0) {
int add = (x % 10ll) * (dig[count] - 1ll) * e10[ex] % p;
gg = (gg + add) % p;
add = (x % 10ll) * (dig[count - 1] - 1ll) * e10[ex - 1] % p;
gg = (gg + add) % p;
for (int j = 1; j < count; j++) {
add = (x % 10ll) * (dig[j] - dig[j + 1]) * e10[count + j - 1] % p;
gg = (gg + add) % p;
}
for (int j = 1; j < count - 1; j++) {
add = (x % 10ll) * (dig[j] - dig[j + 1]) * e10[count + j - 1] % p;
gg = (gg + add) % p;
}
x /= 10;
count++;
ex += 2;
}
}
printf("%d\n", gg);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int binpow(long long int a, long long int b, long long int mod) {
long long int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n, a[100005];
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
map<long long int, long long int> lol, hol;
for (int i = 1; i <= n; i++) {
long long int u = a[i];
long long int o = 0;
while (u > 0) {
u /= 10;
o++;
}
lol[o]++;
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
long long int x = a[i];
std::vector<long long int> v;
while (x > 0) {
v.push_back(x % 10);
x /= 10;
}
for (int j = 1; j <= 12; j++) {
long long int c = 1, temp = 0, temp2 = 0;
long long int len = v.size();
if (len >= j) {
for (int k = 1; k <= j; k++) {
long long int q = binpow(10, c, 998244353);
temp = (temp + (v[k - 1] * q) % 998244353) % 998244353;
long long int yt = binpow(10, c - 1, 998244353);
temp2 = (temp2 + (v[k - 1] * yt) % 998244353) % 998244353;
c += 2;
}
c = 2 * j;
for (int k = j + 1; k <= len; k++) {
long long int q = binpow(10, c, 998244353);
temp = (temp + (v[k - 1] * q) % 998244353) % 998244353;
temp2 = (temp2 + (v[k - 1] * q) % 998244353) % 998244353;
c += 1;
}
} else {
c = 1;
for (int k = 1; k <= len; k++) {
long long int q = binpow(10, c, 998244353);
long long int yt = binpow(10, c - 1, 998244353);
temp = (temp + (v[k - 1] * q) % 998244353) % 998244353;
temp2 = (temp2 + (v[k - 1] * yt) % 998244353) % 998244353;
c += 2;
}
}
ans = (ans + ((temp * (lol[j])) % 998244353 +
(temp2 * (lol[j])) % 998244353) %
998244353) %
998244353;
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 998244353;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
auto get_len = [&](int x) {
int res = 0;
while (x > 0) {
res += 1;
x /= 10;
}
return res;
};
vector<int> len(n);
vector<int> cnt(11, 0);
for (int i = 0; i < n; ++i) {
len[i] = get_len(a[i]);
cnt[len[i]] += 1;
}
vector<long long> p(21);
p[0] = 1;
for (int i = 1; i < 21; ++i) {
p[i] = p[i - 1] * 10 % md;
}
long long ans = 0;
auto geti = [&](int a, int b, int id) {
if (a == b) {
return id * 2 + 1;
}
if (a < b) {
return id * 2 + 1;
}
if (a > b) {
if (id >= b) {
return b + id;
}
return id * 2 + 1;
}
return 1;
};
auto getj = [&](int a, int b, int id) {
if (a == b) {
return id * 2;
}
if (a < b) {
return id * 2;
}
if (a > b) {
if (id >= b) {
return b + id;
}
return id * 2;
}
return 1;
};
for (int i = 0; i < n; ++i) {
vector<int> b;
for (int j = 0; j < len[i]; ++j) {
b.push_back(a[i] % 10);
a[i] /= 10;
}
for (int j = 0; j < len[i]; ++j) {
for (int t = 1; t < 11; ++t) {
ans = (ans + p[geti(len[i], t, j)] * b[j] * cnt[t] % md) % md;
ans = (ans + p[getj(len[i], t, j)] * b[j] * cnt[t] % md) % md;
}
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const long long INF = 1e18;
const double EPS = 1e-6;
const int MAX_N = 1e5 + 5;
long long fastExpo(int base, int e) {
long long ans = 1;
while (e != 0) {
if (e % 2 == 1) ans = (long long)ans * base % MOD;
base = (long long)base * base % MOD;
e /= 2;
}
return ans;
}
namespace modOp {
int add(int a, int b, int mod = MOD) { return (a + b) % mod; }
void ADD(int& a, int b, int mod = MOD) { a = (a + b) % mod; }
int sub(int a, int b, int mod = MOD) { return (a - b + mod) % mod; }
void SUB(int& a, int b, int mod = MOD) { a = (a - b + mod) % mod; }
int mul(int a, int b, int mod = MOD) { return (long long)a * b % mod; }
void MUL(int& a, int b, int mod = MOD) { a = (long long)a * b % mod; }
int divide(int a, int b, int mod = MOD) {
return (long long)a * fastExpo(b, mod - 2) % mod;
}
void DIVIDE(int& a, int b, int mod = MOD) {
a = (long long)a * fastExpo(b, mod - 2) % mod;
}
} // namespace modOp
using namespace modOp;
int n;
string a[MAX_N];
int freq[11];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
++freq[a[i].size()];
reverse(a[i].begin(), a[i].end());
}
int ans = 0, ans2 = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= a[i].size(); ++j) {
int total = 0, total2 = 0;
for (int k = 1; k <= j; ++k) {
ADD(total, mul(a[i][k - 1] - '0', fastExpo(10, k * 2 - 1)));
ADD(total2, mul(a[i][k - 1] - '0', fastExpo(10, k * 2 - 2)));
}
for (int k = j + 1, power = j * 2; k <= a[i].size(); ++k, ++power) {
ADD(total, mul(a[i][k - 1] - '0', fastExpo(10, power)));
ADD(total2, mul(a[i][k - 1] - '0', fastExpo(10, power)));
}
MUL(total, freq[j]);
MUL(total2, freq[j]);
ADD(ans, total);
ADD(ans2, total2);
}
for (int j = a[i].size() + 1; j <= 10; ++j) {
int total = 0, total2 = 0;
for (int k = 1; k <= a[i].size(); ++k) {
ADD(total, mul(a[i][k - 1] - '0', fastExpo(10, k * 2 - 1)));
ADD(total, mul(a[i][k - 1] - '0', fastExpo(10, k * 2 - 2)));
}
MUL(total, freq[j]);
MUL(total2, freq[j]);
ADD(ans, total);
ADD(ans2, total2);
}
}
cout << add(ans, ans2) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<signed long long> V[12];
signed long long p10[12];
signed long long mo = 998244353;
pair<vector<signed long long>, vector<signed long long>> hoge(int a, int b) {
vector<signed long long> A, B;
signed long long p = 1;
while (a && b) {
B.push_back(p);
p = p * 10 % mo;
A.push_back(p);
p = p * 10 % mo;
a--, b--;
}
while (a--) {
A.push_back(p);
p = p * 10 % mo;
}
while (b--) {
B.push_back(p);
p = p * 10 % mo;
}
return {A, B};
}
void solve() {
int i, j, k, l, r, x, y;
string s;
p10[0] = 1;
for (i = 0; i < (11); i++) p10[i + 1] = p10[i] * 10;
cin >> N;
for (i = 0; i < (N); i++) {
cin >> x;
for (j = 0; j < (11); j++)
if (x < p10[j]) break;
V[j].push_back(x);
}
signed long long ret = 0;
for (i = 1; i <= 10; i++) {
for (j = 1; j <= 10; j++) {
auto P = hoge(i, j);
for (auto& v : V[i]) {
signed long long a = v;
for (auto& p : P.first) {
ret += a % 10 * p % mo * V[j].size() % mo;
a /= 10;
}
}
for (auto& v : V[j]) {
signed long long a = v;
for (auto& p : P.second) {
ret += a % 10 * p % mo * V[i].size() % mo;
a /= 10;
}
}
}
}
cout << ret % mo << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f = 0;
int mod = 998244353;
long long fast_expo(long long x, long long y) {
long long res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return (res % mod);
}
int main() {
long long n;
cin >> n;
vector<string> a;
long long h[11] = {0};
for (long long i = 0; i < n; i++) {
string x;
cin >> x;
a.push_back(x);
h[a[a.size() - 1].size()]++;
}
long long dp[1000001] = {0};
for (long long i = 0; i < n; i++) {
for (long long j = a[i].size() - 1; j >= 0; j--) {
long long pos = a[i].size() - j;
for (long long k = 1; k <= 10; k++) {
if (pos > min(pos, k)) {
dp[pos + min(pos, k)] =
(dp[pos + min(pos, k)] + (2 * h[k] * (a[i][j] - 48))) % mod;
} else {
dp[pos + min(pos, k)] =
((dp[pos + min(pos, k)]) % mod + (h[k] * (a[i][j] - 48)) % mod) %
mod;
dp[pos + min(pos, k) - 1] = ((dp[pos + min(pos, k) - 1] % mod +
(h[k] * (a[i][j] - 48)) % mod) %
mod);
}
}
}
}
long long maxi = 0;
for (long long i = 1; i <= 100000; i++) {
if (dp[i] > 0) maxi = max(maxi, i);
}
string ans;
long long sum = 0;
long long P = 10;
long long power = 0;
for (int i = 1; i < maxi; i++) {
long long rem = dp[i] % 10;
long long c = dp[i] / 10;
sum = (sum % mod + rem * (fast_expo(10, power))) % mod;
dp[i + 1] = (dp[i + 1] + c) % mod;
power++;
}
sum = (sum % mod + (((dp[maxi]) % mod) * (fast_expo(10, power)))) % mod;
cout << sum << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e17;
const long long int mod = 998244353;
const long long int MOD = 998244353;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
vector<char *> tokenizer(const char *args) {
char *token = new char[111];
strcpy(token, args);
token = strtok(token, ", ");
vector<char *> v({token});
while ((token = strtok(NULL, ", "))) v.push_back(token);
return reverse(v.begin(), v.end()), v;
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void debugg(vector<char *> args) { cerr << "\b\b "; }
#pragma clang diagnostic pop
template <typename Head, typename... Tail>
void debugg(vector<char *> args, Head H, Tail... T) {
debug() << " [" << args.back() << ": " << H << "] ";
args.pop_back();
debugg(args, T...);
}
template <typename T>
T power(T a, T b) {
if (b == 0) return 1;
if (b == 1)
return a;
else {
T res = (power(a, b / 2));
if (b % 2)
return (res * res * a);
else
return res * res;
}
}
template <typename T>
T power(T a, T b, T modulo) {
if (b == 0) return 1;
if (b == 1)
return a;
else {
T res = (power(a, b / 2, modulo) % modulo);
if (b % 2)
return ((((res % modulo) * (res % modulo)) % modulo) * (a % modulo)) %
modulo;
else
return ((res % modulo) * (res % modulo)) % modulo;
}
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
void factorial(vector<long long int> &fact, long long int n) {
fact.resize(n + 1, 1);
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i <= n; ++i) {
fact[i] = ((fact[i - 1] % mod) * (i % mod)) % mod;
}
}
long long int mod_inv(long long int a) {
return (power<long long int>(a, mod - 2, mod)) % mod;
}
long long int ncr(long long int n, long long int r,
vector<long long int> &fact) {
if (r > n or n < 0 or r < 0) return 0LL;
return (((fact[n] % mod) * (mod_inv(fact[n - r]) % mod)) % mod *
(mod_inv(fact[r]) % mod)) %
mod;
}
vector<long long int> cnt(20, 0);
long long int as_i(long long int n) {
vector<long long int> d;
long long int ans = 0ll;
while (n > 0) {
d.emplace_back(n % 10);
n /= 10;
}
for (long long int j = 1; j <= 10; ++j) {
n = cnt[j];
if (n == 0) continue;
string s;
long long int p = 0;
long long int k = 0, l = 0;
long long int i = 0;
while (((long long int)(s).size()) != ((long long int)(d).size()) + j and
k < ((long long int)(d).size()) and l < j) {
if (p) {
s.push_back('1');
k++;
} else {
s.push_back('0');
l++;
}
i++;
p = p ^ 1;
}
while (((long long int)(s).size()) != ((long long int)(d).size()) + j and
k < ((long long int)(d).size())) {
s.push_back('1');
k++;
i++;
}
while (((long long int)(s).size()) != ((long long int)(d).size()) + j and
l < j) {
s.push_back('1');
l++;
i++;
}
{};
long long int val = 0;
for (int m = 0;
m < ((long long int)(s).size()) and val < ((long long int)(d).size());
++m) {
if (s[m] == '0') continue;
ans = (ans + n * power<long long int>(10, m, mod) * d[val] % mod) % mod;
val++;
}
}
return ans;
}
long long int as_j(long long int n) {
vector<long long int> d;
long long int ans = 0ll;
while (n > 0) {
d.emplace_back(n % 10);
n /= 10;
}
for (long long int j = 1; j <= 10; ++j) {
n = cnt[j];
if (n == 0) continue;
string s;
long long int p = 0;
long long int k = 0, l = 0;
long long int i = 0;
while (((long long int)(s).size()) != ((long long int)(d).size()) + j and
k < ((long long int)(d).size()) and l < j) {
if (p) {
s.push_back('0');
l++;
} else {
s.push_back('1');
k++;
}
i++;
p = p ^ 1;
}
{};
while (((long long int)(s).size()) != ((long long int)(d).size()) + j and
k < ((long long int)(d).size())) {
s.push_back('1');
k++;
i++;
}
while (((long long int)(s).size()) != ((long long int)(d).size()) + j and
l < j) {
s.push_back('0');
l++;
i++;
}
{};
long long int val = 0;
for (int m = 0;
m < ((long long int)(s).size()) and val < ((long long int)(d).size());
++m) {
if (s[m] == '0') continue;
ans = (ans + n * power<long long int>(10, m, mod) * d[val] % mod) % mod;
val++;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long int n;
cin >> n;
vector<long long int> v(n - 1 + 1);
for (auto i = 0; i <= n - 1; i++) {
cin >> v[i];
};
long long int ans = 0ll;
map<long long int, long long int> mp;
for (int i = 0; i < n; ++i) {
long long int x = v[i];
long long int d = 0;
while (x > 0) {
d++;
x /= 10;
}
mp[d]++;
}
for (auto &[a, b] : mp) {
cnt[a] = b;
}
for (int i = 0; i < n; ++i) {
ans = (ans + as_i(v[i])) % mod;
ans = (ans + as_j(v[i])) % mod;
}
ans %= mod;
cout << ((ans)) << "\n";
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
long long mod = 998244353;
long long x, ans;
int n;
vector<long long> v1;
long long sum[11], sizes[11];
long long p(int cnt) {
long long ret = 1;
while (cnt--) {
ret *= 10;
ret %= mod;
}
return ret;
}
long long solve(int x, int sz, int start) {
long long num = 0;
int cnt = start;
string str = to_string(x);
reverse(str.begin(), str.end());
int i = 0;
for (; i < min((int)(str.size()), sz); i++) {
num += (str[i] - '0') * p(cnt);
num %= mod;
cnt += 2;
}
cnt -= start;
for (; i < (int)(str.size()); i++) {
num += (str[i] - '0') * p(cnt);
num %= mod;
cnt++;
}
return num;
}
int main() {
file();
fast();
cin >> n;
v1.resize(n);
for (int i = 0; i < n; i++) {
cin >> v1[i];
sizes[(int)(log10(v1[i]) + 1)]++;
for (int j = 1; j <= 10; j++) {
sum[j] += solve(v1[i], j, 1);
sum[j] %= mod;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
long long num = 0;
for (int j = 1; j <= 10; j++) {
long long take = solve(v1[i], j, 0);
take *= sizes[j];
take %= mod;
num += take;
num %= mod;
}
ans += num;
ans %= mod;
ans += sum[(int)(log10(v1[i]) + 1)];
ans %= mod;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
const int mod = 998244353;
auto solve = [&](string s1, string s2) {
long long p = 1;
int p1 = int(s1.size()) - 1;
int p2 = int(s2.size()) - 1;
long long ret = 0;
while (true) {
if (0 <= p2) {
ret += 1LL * p * (s2[p2--] - '0');
ret %= mod;
p = (p * 10) % mod;
} else {
while (0 <= p1) {
ret += 1LL * p * (s1[p1--] - '0');
ret %= mod;
p = (p * 10) % mod;
}
break;
}
swap(s1, s2);
swap(p1, p2);
}
return ret;
};
vector<vector<int> > fl(11, vector<int>(11, 0));
vector<vector<int> > fr(11, vector<int>(11, 0));
vector<int> vis(11, 0);
for (int i = 0; i < n; i++) {
string si;
cin >> si;
string l = "";
for (int it = 1; it < 11; it++) {
l += "0";
int z = solve(l, si);
fr[it][int(si.size())] += z;
if (fr[it][int(si.size())] >= mod) fr[it][int(si.size())] -= mod;
}
vis[int(si.size())] += 1;
string r = "";
for (int it = 1; it < 11; it++) {
r += "0";
int z = solve(si, r);
fl[int(si.size())][it] += z;
if (fl[int(si.size())][it] >= mod) fl[int(si.size())][it] -= mod;
}
}
long long ans = 0;
for (int l = 1; l < 11; l++) {
if (vis[l] == 0) continue;
for (int r = 1; r < 11; r++) {
if (vis[r] == 0) continue;
long long add = (1LL * vis[r] * fl[l][r] + 1LL * vis[l] * fr[l][r]) % mod;
ans += add;
if (ans >= mod) ans -= mod;
}
}
cout << ans << '\n';
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
string s[120001];
long long p[181], n, i, z, sum, ans;
long long get(long long a, long long b, long long nom) {
if (nom == 1) {
if (a <= b) return a * 2 - 1;
return a + b - 1;
} else {
if (a >= b) return b * 2 - 2;
return a + b - 1;
}
}
long long mod(long long a) { return a % 998244353; }
long long st(long long a, long long b) {
if (b == 0) return 1;
long long c = st(a, b / 2);
if (b % 2 != 0)
return mod(mod(a * c) * c);
else
return mod(c * c);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (i = 1; i <= n; i++) cin >> s[i];
for (z = 1; z <= 10; z++) {
sum = 0;
for (i = 1; i <= n; i++)
if (s[i].size() >= z) sum += s[i][s[i].size() - z] - 48;
for (i = 1; i <= n; i++) {
p[get(z, s[i].size(), 1)] += sum;
p[get(s[i].size(), z, 2)] += sum;
}
}
for (i = 0; i <= 19; i++) ans = mod(ans + mod(p[i]) * st(10, i));
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long f(string s, long long len) {
string t;
for (long long i = s.size() - 1; i >= 0; i--) {
t = s[i] + t;
if (len > 0) {
t = '0' + t;
len--;
}
}
return stoll(t) % mod;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long n;
cin >> n;
const long long maxlen = 10;
vector<vector<long long>> dp(1 + maxlen, vector<long long>(1 + maxlen));
vector<long long> arr(n), cnt(1 + maxlen, 0);
vector<string> brr(n);
for (long long i = 0; i < n; i++) {
cin >> arr[i];
brr[i] = to_string(arr[i]);
cnt[brr[i].size()]++;
for (long long len = 1; len <= maxlen; len++) {
dp[brr[i].size()][len] += f(brr[i], len - 1) * 10;
dp[brr[i].size()][len] %= mod;
}
}
long long res = 0;
for (long long i = 0; i < n; i++) {
for (long long len = 1; len <= maxlen; len++) {
res += cnt[len] * f(brr[i], len) + dp[len][brr[i].size()];
res %= mod;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long MOD = 998244353;
unsigned long long duplicate(long x);
unsigned long long duplicate(long x, int len);
unsigned long long power(int x, int y);
int main() {
long n;
cin >> n;
vector<long> a(n);
long long ans = 0;
for (long i = 0; i < n; ++i) scanf("%d", &a[i]);
vector<int> dgts(11);
for (long i = 0; i < n; ++i) ++dgts[(int)log10(a[i]) + 1];
for (long i = 0; i < n; ++i) {
for (int j = 1; j <= 10; ++j) {
ans += dgts[j] * duplicate(a[i], j);
}
}
printf("%llu", ans % MOD);
return 0;
}
unsigned long long duplicate(long x) {
string temp = to_string(x);
string ans = "";
for (int i = 0; i < temp.length(); ++i) {
ans += temp[i];
ans += temp[i];
}
return stoull(ans.c_str()) % MOD;
}
unsigned long long duplicate(long x, int len) {
string temp = to_string(x);
if (temp.size() <= len) {
return duplicate(x);
} else {
return (2 * stoull(temp.substr(0, temp.length() - len)) *
(unsigned long long)power(10, 2 * len)) %
MOD +
duplicate(stoull(temp.substr(temp.length() - len)));
}
}
unsigned long long power(int x, int y) {
unsigned long long ans = 1;
for (int i = 0; i < y; ++i) ans *= x;
return ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long n;
vector<int> d[100005];
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
void sol() {
cin >> n;
int c[11] = {0};
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
while (x) {
d[i].push_back(x % 10);
x /= 10;
}
c[d[i].size()]++;
}
long long sum = 0;
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= 10; ++j) {
long long f = 0;
if (c[j] > 0) {
long long limit = min(j, d[i].size());
long long k = d[i].size() - 1;
while (k + 1 > limit) {
f = f * 10 + d[i][k];
--k;
}
long long f1 = f;
long long k1 = k;
f1 = f1 * 10 + d[i][k1];
--k1;
for (; k1 >= 0; --k1) {
f1 = (f1 * 100 + d[i][k1]) % mod;
}
f1 = (f1 * 10) % mod;
for (; k >= 0; --k) {
f = (f * 100 + d[i][k]) % mod;
}
sum = (sum + ((f + f1) * c[j]) % mod) % mod;
}
}
}
cout << sum;
}
int main() {
int t = 1;
while (t--) {
sol();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, Mod = 998244353;
string arr[N], s;
long long n, pos, mx, dig, ans, frq[15], fp[25];
void solve(int idx) {
s = arr[idx];
for (int i = 0; i < s.size(); ++i) {
pos = s.size() - i - 1, mx = 2 * pos + 1, dig = s[i] - '0';
for (int j = 0; j < 12; ++j) {
ans += (dig * fp[min(mx, pos + j)] * frq[j]) % Mod;
ans %= Mod;
ans += (dig * fp[min(mx - 1, pos + j)] * frq[j]) % Mod;
ans %= Mod;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n, fp[0] = 1;
for (int i = 0; i < n; ++i) cin >> arr[i], ++frq[arr[i].size()];
for (int i = 1; i < 25; ++i) fp[i] = (fp[i - 1] * 10) % Mod;
for (int i = 0; i < n; ++i) solve(i);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5 + 7, inf = 1e18 + 7, mod = 998244353;
long long tc, n, m, x, a, b, c, d, h, i, j, k, l, id, sum, cnt, ans, tmp, flag,
mn, mx;
long long ar[25], br[25];
string s[N];
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> s[i];
br[s[i].size()]++;
}
for (i = 11; i > 0; i--) br[i] += br[i + 1];
br[0] = n;
for (i = 0; i < n; i++) {
for (j = s[i].size() - 1, k = 1; j >= 0; j--, k++) {
ar[2 * k - 1] += (s[i][j] - '0') * br[k];
ar[2 * k] += (s[i][j] - '0') * br[k];
for (l = 2 * k - 1, h = j; h >= 0; h--, l++)
ar[l] += (s[i][h] - '0') * 2 * (br[k - 1] - br[k]);
}
}
for (i = 1; ar[i]; i++) {
ar[i + 1] += ar[i] / 10;
ar[i] %= 10;
}
for (j = 1, k = 1; j < i; j++, k = (k * 10) % mod) {
ans = (ans + (ar[j] * k) % mod) % mod;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[110000], b[110000], num[20];
long long calc(int t) {
long long p = t;
b[0] = 0;
while (p) {
b[++b[0]] = p % 10;
p /= 10;
}
long long h = t;
long long ret = 0, k = 0, u = 1, w = 0;
for (int i = 1; i <= 10; i++) {
k = (k + b[i] * u % 998244353) % 998244353;
u = (u * 100) % 998244353;
t = t / 10;
if (i <= b[0]) w = (t * u % 998244353 + k) % 998244353;
ret = (ret + w * num[i]) % 998244353;
}
u = 10;
k = 0;
w = 0;
for (int i = 1; i <= 10; i++) {
if (i <= b[0]) w = (h * u % 998244353 + k) % 998244353;
ret = (ret + w * num[i]) % 998244353;
k = (k + b[i] * u % 998244353) % 998244353;
u = u * 100 % 998244353;
h /= 10;
}
return ret;
}
int digit(int t) {
int ret = 0;
while (t) {
ret++;
t /= 10;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
num[digit(a[i])]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + calc(a[i])) % 998244353;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> v(n, 0);
long long a = 0, b = 0;
map<int, int> m;
for (long long i = 0; i < n; i++) {
cin >> v[i];
m[log10(v[i]) + 1]++;
}
for (long long i = 0; i < n; i++) {
for (auto j = m.begin(); j != m.end(); j++) {
long long x = v[i];
long long k = 10;
long long y = 0;
int s = j->first;
while (x > 0) {
if (s == 1) {
y += x * k;
y %= 998244353LL;
break;
}
y += (x % 10) * k;
x /= 10;
k *= 100;
k %= 998244353LL;
y %= 998244353LL;
s--;
}
y = y * (j->second);
y %= 998244353LL;
a += y;
a %= 998244353LL;
x = v[i];
k = 1;
y = 0;
s = j->first;
while (x > 0) {
if (s == 0) {
y += x * k;
y %= 998244353LL;
break;
}
y += (x % 10) * k;
x /= 10;
k *= 100;
k %= 998244353LL;
y %= 998244353LL;
s--;
}
y = y * (j->second);
y %= 998244353LL;
a += y;
a %= 998244353LL;
}
}
cout << (a % 998244353LL);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1};
const int maxn = 1e5 + 5;
const long long mo = 998244353;
long long n;
long long w[maxn];
long long C[55];
long long cnt[maxn];
long long table[5000];
int main() {
scanf("%lld", &n);
memset(cnt, 0, sizeof(cnt));
memset(C, 0, sizeof(C));
table[1] = 1;
for (int i = 2; i <= 150; i++) table[i] = table[i - 1] * 10 % mo;
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
long long t = w[i];
while (t) {
cnt[i]++;
t /= 10;
}
C[cnt[i]]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long t = w[i];
long long a = 0, b = 0, c = 0;
long long tmp = 1;
while (t) {
long long a = t % 10;
t /= 10;
for (int j = 1; j <= 11; j++) {
if (j >= tmp) {
ans += a * table[2 * tmp - 1] % mo * C[j] % mo;
ans %= mo;
ans += a * table[2 * tmp] % mo * C[j] % mo;
ans %= mo;
} else {
ans += a * table[2 * j + tmp - j] % mo * C[j] % mo;
ans %= mo;
ans += a * table[2 * j + tmp - j] % mo * C[j] % mo;
ans %= mo;
}
}
tmp++;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxv = 1e5 + 5;
const long long mod = 998244353;
long long n, a[maxv], ans, digit[33], len[maxv];
bool cmp(long long x, long long y) { return x > y; }
long long quick_pow(long long a, long long b, long long m) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = ans * a % m;
}
a = a * a % m;
b >>= 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
long long now = a[i], co = 0;
while (now) {
co++;
now /= 10;
}
len[i] = co;
digit[co]++;
}
sort(a + 1, a + n + 1, cmp);
for (long long i = 1; i <= n; i++) {
long long now = a[i], pos = 1, co = 0;
long long tmp = now;
for (; tmp; tmp /= 10, co++)
;
while (now) {
for (long long j = co - 1; j >= 1; j--) {
if (j >= pos) {
ans = (ans + (now % 10) * quick_pow(10, 2 * pos - 2, mod) % mod *
digit[j] % mod) %
mod;
ans = (ans + (now % 10) * quick_pow(10, 2 * pos - 1, mod) % mod *
digit[j] % mod) %
mod;
} else
ans = (ans + (now % 10) * quick_pow(10, pos + j - 1, mod) % mod *
digit[j] * 2 % mod) %
mod;
}
for (long long j = co + 1; j <= 20; j++) {
ans = (ans + (now % 10) * quick_pow(10, 2 * pos - 1, mod) % mod *
digit[j] % mod) %
mod;
ans = (ans + (now % 10) * quick_pow(10, 2 * pos - 2, mod) % mod *
digit[j] % mod) %
mod;
}
ans = (ans +
(now % 10) * quick_pow(10, 2 * pos - 2, mod) % mod * digit[co]) %
mod;
ans = (ans +
(now % 10) * quick_pow(10, 2 * pos - 1, mod) % mod * digit[co]) %
mod;
now /= 10;
pos++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long m = 998244353) {
if (y == 0) return 1;
long long p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
long long sum(string s, long long l, long long num) {
if (num == 0) return 0;
long long ans = 0;
long long curr_len = s.size();
long long total_len = curr_len + l;
long long maxl = min(l, curr_len) * 2;
long long bar = 0;
if (curr_len > l) {
while (curr_len > l) {
ans += ((((((s[bar] - '0') *
((long long)power(10, total_len - 1) % 998244353)) %
998244353) *
num) %
998244353) *
2) %
998244353;
ans %= 998244353;
bar++;
total_len--;
curr_len--;
}
}
while (maxl > 0) {
ans += ((((s[bar] - '0') * ((long long)power(10, maxl - 1)) % 998244353) %
998244353) *
num) %
998244353;
ans += ((((s[bar] - '0') * ((long long)power(10, maxl - 2)) % 998244353) %
998244353) *
num) %
998244353;
maxl -= 2;
bar++;
}
return ans;
}
signed main() {
long long n;
cin >> n;
string a[n];
long long nums[11] = {0};
for (long long i = 0; i <= n - 1; i++) {
cin >> a[i];
nums[a[i].size()]++;
}
long long ans = 0;
for (long long i = 0; i <= n - 1; i++) {
for (long long len = 1; len <= 10; len++) {
ans = (ans + sum(a[i], len, nums[len])) % 998244353;
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 998244353;
inline int read() {
char c = getchar();
int t = 0, f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
t = (t << 3) + (t << 1) + (c ^ 48);
c = getchar();
}
return t * f;
}
int n, len[maxn], t[20];
long long a[maxn], sum[20][20];
long long wmh[10], cnt;
void fenjie(long long x) {
if (x == 0) {
cnt = 1;
wmh[1] = 0;
}
cnt = 0;
while (x) {
wmh[++cnt] = x % 10;
x /= 10;
}
return;
}
long long p[20];
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
p[0] = 1;
for (int i = 1; i <= 19; i++) p[i] = p[i - 1] * 10 % mod;
long long ans = 0;
for (int i = 1; i <= n; i++) {
fenjie(a[i]);
len[i] = cnt;
t[len[i]]++;
for (int j = cnt; j >= 1; j--) sum[cnt][j] += wmh[j];
}
for (int i = 1; i <= n; i++) {
fenjie(a[i]);
for (int j = 1; j <= 10; j++) {
if (!t[j]) continue;
if (j <= cnt) {
for (int k = cnt; k > j; k--) {
ans = (ans + wmh[k] * p[j + k - 1] % mod * t[j] % mod) % mod;
}
for (int k = j; k >= 1; k--) {
ans = ((ans + wmh[k] * p[k * 2 - 1] % mod * t[j] % mod) % mod +
sum[j][k] * p[k * 2 - 2] % mod) %
mod;
}
} else {
for (int k = j; k > cnt; k--) {
ans = (ans + sum[j][k] * p[cnt + k - 1] % mod) % mod;
}
for (int k = cnt; k >= 1; k--) {
ans = ((ans + wmh[k] * p[2 * k - 1] % mod * t[j] % mod) % mod +
sum[j][k] * p[k * 2 - 2] % mod) %
mod;
}
}
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 998244353;
long long get_length(long long n) {
if (n == 0) return 0;
return get_length(n / 10) + 1;
}
long long N;
long long get_ze0(long long n, long long cnt) {
if (cnt <= 0) return n;
if (n / 10 == 0) return n * 10;
return (get_ze0(n / 10, cnt - 1) * 100 + n % 10 * 10) % MOD;
}
long long get_ze1(long long n, long long cnt) {
if (cnt <= 0) return n;
if (n / 10 == 0) return n;
return (get_ze1(n / 10, cnt - 1) * 100 + n % 10) % MOD;
}
long long cnt_legth[11];
long long zero_added[111111][2][11];
long long legth[111111];
int main(void) {
scanf("%lld", &N);
for (long long i = 1; i <= N; ++i) {
scanf("%lld", &zero_added[i][1][0]);
legth[i] = get_length(zero_added[i][1][0]);
cnt_legth[legth[i]]++;
for (long long j = 1; j < 11; ++j) {
zero_added[i][0][j] = get_ze0(zero_added[i][1][0], j);
zero_added[i][1][j] = get_ze1(zero_added[i][1][0], j);
}
}
long long res = 0;
for (long long i = 1; i <= N; ++i) {
for (long long l = 1; l < 11; ++l) {
res += cnt_legth[l] * ((zero_added[i][0][l] + zero_added[i][1][l]) % MOD);
res %= MOD;
}
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<long long, int>> v;
vector<int> d(10, 0);
vector<long long> r(1000, 0);
for (int i = 0; i < n; ++i) {
long long a;
int t = -1;
cin >> a;
if (a < 10) {
++d[0];
t = 0;
}
if (a < 100 && t == -1) {
++d[1];
t = 1;
}
if (a < 1000 && t == -1) {
++d[2];
t = 2;
}
if (a < 10000 && t == -1) {
++d[3];
t = 3;
}
if (a < 100000 && t == -1) {
++d[4];
t = 4;
}
if (a < 1000000 && t == -1) {
++d[5];
t = 5;
}
if (a < 10000000 && t == -1) {
++d[6];
t = 6;
}
if (a < 100000000 && t == -1) {
++d[7];
t = 7;
}
if (a < 1000000000 && t == -1) {
++d[8];
t = 8;
}
if (t == -1) {
++d[9];
t = 9;
}
v.push_back({a, t});
}
for (int i = 0; i < n; ++i) {
vector<int> num;
while (v[i].first > 0) {
num.push_back(v[i].first % 10);
v[i].first /= 10;
}
for (int j = 0; j < 10; ++j) {
if (d[j] > 0) {
if (v[i].second > j) {
for (int k = 0; k <= j; ++k) {
r[k * 2] += d[j] * num[k];
r[k * 2 + 1] += d[j] * num[k];
}
for (int k = j + 1; k < num.size(); ++k) {
r[(j + 1) * 2 + k - j - 1] += d[j] * num[k] * 2;
}
} else {
for (int k = 0; k < num.size(); ++k) {
r[k * 2] += d[j] * num[k];
r[k * 2 + 1] += d[j] * num[k];
}
}
}
}
}
long long j = 0, k = 0;
while (r[j] > 0) {
r[j] += k;
k = r[j] / 10;
r[j] %= 10;
++j;
}
k %= mod;
k += r[j];
--j;
while (j > -1) {
k = k * 10 + r[j];
k %= mod;
--j;
}
cout << k;
return 0;
}
|
#include <bits/stdc++.h>
const long long int INF = 1e15;
using namespace std;
const long long int MAX = 1e6 + 5;
const long long int mod = 998244353;
long long int gcd(long long int a, long long int b) {
while (b > 0) {
a = a % b;
swap(a, b);
}
return a;
}
long long int binpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b % 2 == 1) res = res * a % mod;
a = a * a % mod;
b /= 2;
}
return res % mod;
}
void solve() {
long long int n;
cin >> n;
long long int ar[n];
long long int digits[11] = {};
long long int k;
long long int cnt;
for (long long int i = 0; i < n; i++) {
cin >> ar[i];
k = ar[i];
cnt = 0;
while (k) {
cnt++;
k /= 10;
}
digits[cnt]++;
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
long long int cur = 0;
k = ar[i];
cnt = 0;
while (k) {
long long int digit = k % 10;
for (long long int i = 1; i < cur; i++) {
ans += (binpow(10, cur + i) * digit % mod) * digits[i] % mod;
if (ans > mod) ans %= mod;
}
long long int res = 0;
for (long long int i = cur; i < 11; i++) {
res += digits[i];
}
ans += (binpow(10, 2 * cur) * digit % mod) * res % mod;
if (ans > mod) ans %= mod;
cur++;
k /= 10;
}
}
for (long long int i = 0; i < n; i++) {
long long int cur = 0;
k = ar[i];
cnt = 0;
while (k) {
long long int digit = k % 10;
for (long long int i = 1; i <= cur; i++) {
ans += (binpow(10, cur + i) * digit % mod) * digits[i] % mod;
if (ans > mod) ans %= mod;
}
long long int res = 0;
for (long long int i = cur + 1; i < 11; i++) {
res += digits[i];
}
ans += (binpow(10, 2 * cur + 1) * digit % mod) * res % mod;
if (ans > mod) ans %= mod;
cur++;
k /= 10;
}
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100000;
const int MOD = 998244353;
long long a[MAX + 10], s[50], sum[50], len[MAX + 10];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
s[0] = 1;
for (int i = 1; i <= 20; ++i) {
s[i] = s[i - 1] * 10 % MOD;
}
int n;
cin >> n;
int maxlen = 0, minlen = INT_MAX;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
long long t = a[i];
int cnt = 0;
while (t) {
t /= 10;
++cnt;
}
++sum[cnt];
len[i] = cnt;
maxlen = max(maxlen, cnt);
minlen = min(minlen, cnt);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int leni = len[i];
for (int j = minlen; j <= maxlen; ++j) {
int cnt = 0;
long long tmp = a[i];
while (tmp) {
long long t = tmp % 10;
if (cnt < 2 * min(leni, j)) {
ans = (ans + t * s[cnt++] % MOD * sum[j]) % MOD;
ans = (ans + t * s[cnt++] % MOD * sum[j]) % MOD;
} else {
ans = (ans + t * s[cnt++] % MOD * sum[j] * 2) % MOD;
}
tmp /= 10;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long mod = 1000000007;
long long mod2 = 998244353;
long long OO = 1e18;
using namespace std;
long long ans[500500];
long long cnt[500];
long long n, a[100100];
vector<long long> v;
void Get_digit(long long x) {
while (x) {
v.push_back(x % 10);
x /= 10;
}
}
int main() {
long long i, j;
;
long long k;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
Get_digit(a[i]);
cnt[v.size()]++;
v.clear();
}
for (i = 0; i < n; i++) {
Get_digit(a[i]);
for (k = 1; k <= 11; k++) {
if (k >= v.size()) {
for (j = 0; j < v.size(); j++) {
ans[(j + 1) * 2 - 1] += v[j] * cnt[k];
ans[(j + 1) * 2] += v[j] * cnt[k];
}
} else {
for (j = 0; j < k; j++) {
ans[(j + 1) * 2 - 1] += v[j] * cnt[k];
ans[(j + 1) * 2] += v[j] * cnt[k];
}
long long indx = k * 2 + 1;
for (j = k; j < v.size(); j++) {
ans[indx] += v[j] * cnt[k] * 2;
indx++;
}
}
}
v.clear();
}
long long load = 0;
for (i = 1; i < 500400; i++) {
ans[i] += load;
load = ans[i] / 10;
ans[i] %= 10;
}
long long x = 0;
for (i = 500400; i > 0; i--) {
x += ans[i];
if (i != 1) x *= 10;
x %= mod2;
}
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
int gmax(T &a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int gmin(T &a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
const int MAXN = 1e5 + 5;
const int MOD = 998244353;
int a[MAXN];
int has[15];
int sum[15];
long long sum2[15];
long long ten[25];
long long Pow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = 1ll * ans * x % MOD;
x = 1ll * x * x % MOD;
y >>= 1;
}
return ans;
}
long long getSum2(int x) {
if (x <= 0)
return 0;
else
return sum2[x];
}
int getSum(int x) {
if (x <= 0)
return 0;
else
return sum[x];
}
int main() {
int n;
ten[0] = 1;
for (int i = 1; i < 25; ++i) {
ten[i] = ten[i - 1] * 10 % MOD;
}
while (~scanf("%d", &n)) {
memset(has, 0, sizeof(has));
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
int tmp = a[i];
int cnt = 0;
while (tmp) {
cnt++;
tmp /= 10;
}
has[cnt]++;
}
sum[0] = 0;
for (int i = 1; i < 15; ++i) {
sum[i] = sum[i - 1] + has[i];
}
sum2[0] = 0;
for (int i = 1; i < 15; ++i) {
sum2[i] = (sum2[i - 1] + 1ll * has[i] * ten[i] % MOD) % MOD;
}
long long result = 0;
for (int i = 0; i < n; ++i) {
int tmp = a[i];
int cnt = 1;
while (tmp) {
int tt = tmp % 10;
result =
(result + tt * getSum2(cnt - 2) % MOD * ten[cnt - 1] % MOD) % MOD;
result = (result +
tt * (n - getSum(cnt - 2)) % MOD * ten[cnt * 2 - 2] % MOD) %
MOD;
result =
(result + tt * getSum2(cnt - 1) % MOD * ten[cnt - 1] % MOD) % MOD;
result = (result +
tt * (n - getSum(cnt - 1)) % MOD * ten[cnt * 2 - 1] % MOD) %
MOD;
tmp /= 10;
cnt++;
}
}
printf("%lld\n", result);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
const long long int MOD = 998244353;
long long int N, K, valore;
long long int A[MAXN];
long long int cont[50], mult[50];
void calcMult() {
mult[0] = 1;
for (int i = 1; i < 50; i++) {
mult[i] = mult[i - 1] * 10;
mult[i] %= MOD;
}
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> A[i];
long long int temp = A[i];
int index = -1;
while (temp) {
index++;
temp /= 10;
}
cont[index]++;
}
calcMult();
long long int sol = 0;
for (int i = 0; i < N; i++) {
long long int temp = A[i];
int index = 0;
while (temp) {
long long int cifra = temp % 10;
for (int j = 0; j < 50; j++) {
if (cont[j]) {
if (j < index) {
sol += cont[j] * 2 * cifra * mult[(j)*2 + 2 + (index - j - 1)];
sol %= MOD;
} else {
sol += cont[j] * cifra * mult[(index)*2];
sol %= MOD;
sol += cont[j] * cifra * mult[(index)*2 + 1];
sol %= MOD;
}
}
}
temp /= 10;
index++;
}
}
cout << sol;
}
|
#include <bits/stdc++.h>
const int INF = (int)1e9;
using namespace std;
int MOD = 998244353;
long long shuffle(string s, int k, bool flag) {
long long num = 0;
long long p = ((flag) ? 10 : 1);
for (int i = (int)s.size() - 1, j = 1; i >= 0; i--, j++) {
num += (s[i] - '0') * p;
p *= ((j > k - (flag)) ? 10 : 100);
num %= MOD, p %= MOD;
}
return num;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<string> a(n);
vector<int> len(11);
for (int i = 0; i < n; i++) {
cin >> a[i];
len[(int)a[i].size()]++;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 10; j++) {
long long f = shuffle(a[i], j, false);
long long s = shuffle(a[i], j, true);
f %= MOD, s %= MOD;
ans += (len[j] * f) % MOD + (len[j] * s) % MOD;
ans %= MOD;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long mod = 998244353;
string a[100005];
multiset<unsigned long long> s;
map<unsigned long long, unsigned long long> mp;
int main() {
unsigned long long n;
cin >> n;
unsigned long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i].length()] += 1;
}
for (int i = 0; i < n; i++) {
for (map<unsigned long long, unsigned long long>::iterator it = mp.begin();
it != mp.end(); it++) {
unsigned long long fir = it->first;
unsigned long long sec = it->second;
unsigned long long t1 = 0;
unsigned long long t2 = 0;
unsigned long long t = 0;
unsigned long long temp;
if (fir < a[i].length()) {
for (int j = 0; j < a[i].length() - fir; j++) {
t *= 10;
t += (a[i][j] - '0');
}
t1 = t;
t2 = t;
for (int j = a[i].length() - fir; j <= a[i].length() - 1; j++) {
t1 *= 100;
t1 += (a[i][j] - '0');
t2 *= 10;
t2 += (a[i][j] - '0');
t2 *= 10;
}
temp = t1 + t2;
} else if (fir == a[i].length()) {
for (int j = 0; j < a[i].length(); j++) {
t *= 10;
t += (a[i][j] - '0');
t *= 10;
t += (a[i][j] - '0');
}
temp = t;
} else {
for (int j = 0; j < a[i].length(); j++) {
t1 *= 100;
t1 += (a[i][j] - '0');
t2 *= 10;
t2 += (a[i][j] - '0');
t2 *= 10;
}
temp = t1 + t2;
}
temp %= mod;
temp *= sec;
temp %= mod;
ans += temp;
ans %= mod;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mx(long long x, long long n) {
if (!n)
return 1;
else if (n % 2 == 0)
return mx((x * x) % 998244353, n / 2);
else
return (x * mx((x * x) % 998244353, (n - 1) / 2)) % 998244353;
}
long long modinv(long long n) { return mx(n, 1000000007 - 2); }
void bfs(vector<int> g[], int s, int n) {
queue<long long> q;
bool vis[n];
memset(vis, false, sizeof(vis));
vis[s] = true;
q.push(s);
while (!q.empty()) {
long long temp = q.front();
q.pop();
for (auto it : g[temp]) {
if (vis[it] == false) {
q.push(it);
vis[it] = true;
}
}
}
}
void dfs(vector<int> g[], int src, bool vis[]) {
vis[src] = true;
for (auto it : g[src]) {
if (vis[it] == false) {
dfs(g, it, vis);
}
}
}
bool compare(string a, string b) { return a.length() < b.length(); }
long long n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
string a[n];
map<long long, vector<string>> mpp;
for (long long i = 0; i < n; i++)
cin >> a[i], mpp[a[i].size()].push_back(a[i]);
long long l1, l2, ta = 0, ans = 0, count, d, t;
for (auto iterator : mpp) {
for (auto iterator2 : mpp) {
l1 = iterator.first;
l2 = iterator2.first;
if (l1 >= l2) {
ta = 0;
d = l1 - l2;
for (auto iterator3 : iterator.second) {
count = 1;
for (long long k = l1 - 1; k >= d; k--) {
t = iterator3[k] - '0';
ta = (ta % 998244353 +
(t % 998244353 * mx(10, count) % 998244353) % 998244353) %
998244353;
count += 2;
}
count--;
for (long long k = d - 1; k >= 0; k--) {
t = iterator3[k] - '0';
ta = (ta % 998244353 +
(t % 998244353 * mx(10, count) % 998244353) % 998244353) %
998244353;
count++;
}
count = 0;
for (long long k = l1 - 1; k >= d; k--) {
t = iterator3[k] - '0';
ta = (ta % 998244353 +
(t % 998244353 * mx(10, count) % 998244353) % 998244353) %
998244353;
count += 2;
}
for (long long k = d - 1; k >= 0; k--) {
t = iterator3[k] - '0';
ta = (ta % 998244353 +
(t % 998244353 * mx(10, count) % 998244353) % 998244353) %
998244353;
count++;
}
}
ans = (ans % 998244353 +
(ta % 998244353 * (iterator2.second.size()) % 998244353) %
998244353) %
998244353;
if (!d) continue;
ta = 0;
for (auto iterator3 : iterator2.second) {
count = 0;
for (long long k = l2 - 1; k >= 0; k--) {
t = iterator3[k] - '0';
ta = (ta % 998244353 +
(t % 998244353 * mx(10, count) % 998244353) % 998244353) %
998244353;
count += 2;
}
count = 1;
for (long long k = l2 - 1; k >= 0; k--) {
t = iterator3[k] - '0';
ta = (ta % 998244353 +
(t % 998244353 * mx(10, count) % 998244353) % 998244353) %
998244353;
count += 2;
}
}
ans = (ans % 998244353 +
(ta % 998244353 * (iterator.second.size()) % 998244353) %
998244353) %
998244353;
ta = 0;
}
}
}
cout << ans % 998244353;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long int gcd(unsigned long long int a, unsigned long long int b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
unsigned long long int power(unsigned long long int x, unsigned long long int y,
unsigned long long int md = 998244353) {
unsigned long long int res = 1;
x %= md;
while (y > 0) {
if (y & 1) res = (res * x) % md;
x = (x * x) % md;
y = y >> 1;
}
return res % md;
}
bool sortbysec(const pair<unsigned long long int, unsigned long long int> &a,
const pair<unsigned long long int, unsigned long long int> &b) {
return (a.second < b.second);
}
unsigned long long int len(unsigned long long int v) {
unsigned long long int len = 0;
while (v > 0) {
v /= 10;
len++;
}
return len;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
unsigned long long int n;
cin >> n;
unsigned long long int arr[n], temp;
map<unsigned long long int, unsigned long long int> make_pair;
for (unsigned long long int i = 0; i < n; i++) {
cin >> arr[i];
temp = len(arr[i]);
make_pair[temp]++;
}
map<unsigned long long int, unsigned long long int>::iterator it;
unsigned long long int maxx = 0, cnt = 0;
for (it = make_pair.begin(); it != make_pair.end(); it++) {
if (it->first > maxx) maxx = it->first;
cnt++;
}
unsigned long long int sum = 0;
unsigned long long int brr[20], crr[20];
for (unsigned long long int i = 0; i < n; i++) {
memset(brr, 0, sizeof(brr));
memset(crr, 0, sizeof(crr));
string c = "";
unsigned long long int temp = arr[i], temp2;
while (temp > 0) {
temp2 = temp % 10;
temp /= 10;
c += (char)(48 + temp2);
}
string temp3 = c, temp4;
for (unsigned long long int j = 0; j < c.length(); j++) {
temp3.insert(j * 2, "0");
temp4 = temp3;
reverse(temp4.begin(), temp4.end());
unsigned long long int tt = 0;
for (unsigned long long int k = 0; k < temp4.length(); k++) {
tt *= 10;
tt += temp4[k] - '0';
}
brr[j + 1] = tt;
}
for (unsigned long long int i = 1; i < 20; i++) {
crr[i - 1] = brr[i] / 10;
}
for (unsigned long long int i = 1; i < 20; i++) {
if (brr[i] == 0) brr[i] = brr[i - 1];
if (crr[i] == 0) crr[i] = crr[i - 1];
}
it = make_pair.begin();
while (it != make_pair.end()) {
sum += (((it->second) % 998244353) * (brr[it->first] % 998244353)) %
998244353;
sum %= 998244353;
sum += (((it->second) % 998244353) * (crr[it->first] % 998244353)) %
998244353;
sum %= 998244353;
it++;
}
}
cout << sum % 998244353 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
long long powa[25];
powa[0] = 1;
for (long long i = 1; i < 25; i++) {
powa[i] = powa[i - 1] * 10;
powa[i] %= 998244353;
}
long long store[n][12];
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 1; j < 12; j++) {
long long temp = arr[i];
long long cnt = 0;
long long tempo = 0;
long long mul = 1;
while (cnt < j && temp > 0) {
tempo += ((temp % 10) * mul) % 998244353;
tempo %= 998244353;
mul *= 100;
mul %= 998244353;
temp /= 10;
cnt++;
}
tempo *= 11;
tempo %= 998244353;
tempo += (((2 * temp) % 998244353) * (powa[2 * j])) % 998244353;
tempo %= 998244353;
store[i][j] = tempo;
}
}
long long bcnt[n];
unordered_map<long long, long long> hold;
for (long long i = 0; i < n; i++) {
long long temp = arr[i];
long long cnt = 0;
while (temp != 0) {
temp /= 10;
cnt++;
}
hold[cnt]++;
bcnt[i] = cnt;
}
for (long long i = 0; i < n; i++) {
for (auto it = hold.begin(); it != hold.end(); it++) {
ans += (it->second * (store[i][it->first])) % 998244353;
ans %= 998244353;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long rint() {
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 * 10 + c - '0';
c = getchar();
}
return x * f;
}
inline long long gcd(long long a, long long b) {
return (b) ? gcd(b, a % b) : a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long pow(long long a, long long b, long long q) {
long long rtn = 1;
while (b) {
if (b & 1) rtn = rtn * a % q;
a = a * a % q;
b >>= 1;
}
return rtn;
}
inline long long mysqrt(long long n) {
long long x = sqrt(n);
while (x * x < n) x++;
while (x * x > n) x--;
return x;
}
const long long MOD = 998244353;
int n;
int siz[20], s[20];
vector<int> a[101010];
long long ans;
void upd(long long &a, long long b) {
a = a + b;
a %= MOD;
}
void solve(vector<int> &sb) {
upd(ans, sb[0] * n % MOD);
upd(ans, sb[0] * n % MOD * 10 % MOD);
for (int i = (1); i < (sb.size()); i++) {
long long bas = 1;
for (int j = (0); j < (i); j++) bas = bas * 10 % MOD;
for (int j = (1); j < (i); j++) {
bas = bas * 10 % MOD;
upd(ans, sb[i] * bas % MOD * siz[j] % MOD * 2 % MOD);
}
bas = bas * 10 % MOD;
upd(ans, sb[i] * bas % MOD * siz[i] % MOD * 2 % MOD);
upd(ans, sb[i] * bas % MOD * (s[19] - s[i]) % MOD);
bas = bas * 10 % MOD;
upd(ans, sb[i] * bas % MOD * (s[19] - s[i]) % MOD);
}
}
int main() {
n = rint();
for (int i = (0); i < (n); i++) {
int t = rint();
while (t != 0) {
a[i].push_back(t % 10);
t /= 10;
}
siz[a[i].size()]++;
}
for (int i = (1); i < (20); i++) s[i] = s[i - 1] + siz[i];
for (int i = (0); i < (n); i++) solve(a[i]);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int n, i, j, k;
cin >> n;
unsigned long long int ans = 0;
unsigned long long int digits[12] = {0};
unsigned long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
unsigned long long int x = a[i];
unsigned long long int ct = 0;
while (x > 0) {
ct++;
x /= 10;
}
digits[ct]++;
}
unsigned long long int backward[n][12];
unsigned long long int forwardd[n][12];
for (i = 0; i < n; i++) {
unsigned long long int no_of_dig = 0;
unsigned long long int y = a[i];
while (y > 0) {
no_of_dig++;
y /= 10;
}
for (j = 0; j < no_of_dig; j++) {
unsigned long long int temp = no_of_dig - 1 - j;
unsigned long long int x = a[i];
vector<unsigned long long int> v;
while (x > 0) {
v.push_back(x % 10);
x /= 10;
}
reverse(v.begin(), v.end());
unsigned long long int xx = 0;
for (k = 0; k < no_of_dig; k++) {
xx = (xx * 10) + v[k];
xx = xx % 998244353;
if (k != no_of_dig - 1 && k >= temp) {
xx = (xx * 10);
}
xx = xx % 998244353;
}
backward[i][j] = xx;
forwardd[i][j + 1] = (xx * 10) % 998244353;
}
for (j = no_of_dig; j < 12; j++) {
backward[i][j] = backward[i][j - 1];
if (j + 1 < 12) forwardd[i][j + 1] = forwardd[i][j];
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < 12; j++) {
ans = ((ans % 998244353) + ((backward[i][j] * digits[j]) % 998244353)) %
998244353;
}
for (j = 1; j < 12; j++) {
ans = ((ans % 998244353) + ((forwardd[i][j] * digits[j]) % 998244353)) %
998244353;
}
}
cout << ans % 998244353;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int mod = 998244353;
int a[N], cnt[100], sz[N];
long long pw[100];
int main() {
int n;
scanf("%d", &n);
pw[0] = 1;
for (int i = 1; i <= 30; i++) pw[i] = pw[i - 1] * 10 % mod;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
sz[i] = 0;
int b = a[i];
while (b) {
sz[i]++;
b /= 10;
}
cnt[sz[i]]++;
}
long long res = 0;
for (int i = 1; i <= n; i++) {
int b = a[i];
int pos = 0;
while (b) {
int c = b % 10;
b /= 10;
pos++;
for (int j = 1; j <= 10; j++) {
if (j < pos) {
res += c * cnt[j] * pw[pos + j - 1];
} else {
res += c * cnt[j] * pw[(pos - 1) * 2];
}
if (j <= pos) {
res += c * cnt[j] * pw[pos + j - 1];
} else {
res += c * cnt[j] * pw[pos * 2 - 1];
}
res %= mod;
}
}
}
printf("%lld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 7;
const double PI = acos(-1);
long long mod = 998244353;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<pair<long long, long long>> v;
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
long long b = a;
long long cnt = 0;
while (b) {
cnt++;
b /= 10;
}
v.push_back({cnt, a});
}
sort(v.begin(), v.end());
vector<long long> tmp;
long long presum = 0;
long long pre[N];
int idx = 1;
pre[0] = 0;
for (auto it : v) {
tmp.push_back(it.first);
long long len = it.first;
long long pow = 1;
len--;
while (len--) {
pow *= 10;
pow %= mod;
}
presum += pow;
presum %= mod;
pre[idx] = presum;
idx++;
}
long long ans = 0;
for (auto it : v) {
long long a = it.second;
long long idx = 0;
while (a) {
long long d = a % 10;
int low = lower_bound(tmp.begin(), tmp.end(), idx) - tmp.begin();
long long ng = n - low;
long long val = 2 * idx;
long long pow = 1;
while (val--) {
pow *= 10;
pow %= mod;
}
long long mul = 1;
val = idx + 1;
while (val--) {
mul *= 10;
mul %= mod;
}
ans += d * (((ng * pow) % mod + (pre[low] * mul) % mod) % mod);
ans %= mod;
low = lower_bound(tmp.begin(), tmp.end(), idx + 1) - tmp.begin();
ng = n - low;
val = 2 * idx + 1;
pow = 1;
while (val--) {
pow *= 10;
pow %= mod;
}
ans += d * (((ng * pow) % mod + (pre[low] * mul) % mod) % mod);
ans %= mod;
a /= 10;
idx++;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
char str[1001];
int n;
int ans = 0, sum[101], len;
int f[100005][12], g[100005][12];
int m[101];
int c[100005];
int main() {
scanf("%d", &n);
m[0] = 1;
for (int i = 1; i <= 25; i++) m[i] = 1LL * m[i - 1] * 10 % mod;
for (int i = 1; i <= n; i++) {
scanf("%s", str + 1);
len = (int)strlen(str + 1);
for (int j = 1; j <= 10; j++) {
if (j > len) {
for (int k = 1; k <= len; k++)
f[i][j] = (1LL * f[i][j] * 100 + str[k] - '0') % mod;
f[i][j] = 10LL * f[i][j] % mod;
} else if (j < len) {
for (int k = 1; k <= len - j; k++)
f[i][j] = (1LL * f[i][j] * 10 + str[k] - '0') % mod;
f[i][j] = 1LL * f[i][j] * m[2 * j] % mod;
int tmp = 0;
for (int k = len - j + 1; k <= len; k++)
tmp = (1LL * tmp * 100 + str[k] - '0') % mod;
f[i][j] += 10LL * tmp % mod;
f[i][j] %= mod;
} else {
for (int k = 1; k <= 2 * len; k++)
f[i][j] = (1LL * f[i][j] * 10 + str[(k + 1) / 2] - '0') % mod;
}
}
for (int j = 1; j <= 10; j++) {
if (j > len) {
for (int k = 1; k <= len; k++)
g[i][j] = (1LL * g[i][j] * 100 + str[k] - '0') % mod;
} else if (j < len) {
for (int k = 1; k <= len - j; k++)
g[i][j] = (1LL * g[i][j] * 10 + str[k] - '0') % mod;
g[i][j] = 1LL * g[i][j] * m[2 * j] % mod;
int tmp = 0;
for (int k = len - j + 1; k <= len; k++)
tmp = (1LL * tmp * 100 + str[k] - '0') % mod;
g[i][j] += tmp;
g[i][j] %= mod;
} else {
g[i][j] = 0;
}
f[i][j] += g[i][j];
f[i][j] %= mod;
}
sum[len]++;
c[i] = len;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 10; j++) {
ans += 1LL * f[i][j] * sum[j] % mod;
ans %= mod;
}
}
printf("%d\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.