text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-10;
const double PI = acos(-1.0);
template <typename T1, typename T2>
ostream& operator<<(ostream& s, const pair<T1, T2>& d) {
return s << "(" << d.first << "," << d.second << ")";
}
long long dp[3001][101][2];
const long long MOD = 1000000007;
int main() {
int n, l;
cin >> n >> l;
vector<pair<int, int> > board(n);
for (int i = 0; i < (n); ++i) cin >> board[i].first >> board[i].second;
for (int i = 1; i <= l; i++) {
for (int j = 0; j < board.size(); j++) {
if (i - board[j].first >= 0) {
if (i - board[j].first == 0) {
dp[i][j][0] = 1;
} else {
for (int k = 0; k < board.size(); k++) {
if (j == k) continue;
if (board[k].second == board[j].first) {
dp[i][j][0] += dp[i - board[j].first][k][0];
}
if (board[k].first == board[j].first) {
dp[i][j][0] += dp[i - board[j].first][k][1];
}
dp[i][j][0] %= MOD;
}
}
}
if (board[j].first != board[j].second && i - board[j].second >= 0) {
if (i - board[j].second == 0) {
dp[i][j][1] = 1;
} else {
for (int k = 0; k < board.size(); k++) {
if (j == k) continue;
if (board[k].second == board[j].second) {
dp[i][j][1] += dp[i - board[j].second][k][0];
}
if (board[k].first == board[j].second) {
dp[i][j][1] += dp[i - board[j].second][k][1];
}
dp[i][j][1] %= MOD;
}
}
}
}
}
long long ans = 0;
for (int i = 0; i < (board.size()); ++i) {
ans += dp[l][i][0] + dp[l][i][1];
ans %= MOD;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans[6002][102][2];
int a[202], b[202];
int i, j, k, n, l;
int main() {
cin >> n >> l;
for (i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
ans[a[i]][i][0] = 1;
if (a[i] != b[i]) ans[b[i]][i][1] = 1;
}
for (i = 0; i <= l; i++)
for (j = 1; j <= n; j++)
for (k = 1; k <= n; k++)
if (j != k) {
if (a[k] == a[j]) ans[i + a[k]][k][0] += ans[i][j][1];
if (a[k] == b[j]) ans[i + a[k]][k][0] += ans[i][j][0];
ans[i + a[k]][k][0] %= 1000000007;
if (a[k] != b[k]) {
if (b[k] == a[j]) ans[i + b[k]][k][1] += ans[i][j][1];
if (b[k] == b[j]) ans[i + b[k]][k][1] += ans[i][j][0];
ans[i + b[k]][k][1] %= 1000000007;
}
}
long long res = 0;
for (i = 1; i <= n; i++)
res = (res + ans[l][i][0] + ans[l][i][1]) % 1000000007;
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const long long MOD = 1e9 + 7;
long long dp[3005][105][2];
int n, l, A[105], B[105];
long long ans = 0;
void work() {
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
dp[A[i]][i][0] = 1;
if (B[i] != A[i]) dp[B[i]][i][1] = 1;
}
for (int i = 1; i <= l; i++)
for (int j = 1; j <= n; j++)
for (int h = 0; h <= 1; h++)
if (dp[i][j][h]) {
for (int k = 1; k <= n; k++)
if (k != j) {
if (i + A[k] <= l && A[k] == (h == 0 ? B[j] : A[j]))
dp[i + A[k]][k][0] = (dp[i + A[k]][k][0] + dp[i][j][h]) % MOD;
if (A[k] != B[k] && i + B[k] <= l &&
B[k] == (h == 0 ? B[j] : A[j]))
dp[i + B[k]][k][1] = (dp[i + B[k]][k][1] + dp[i][j][h]) % MOD;
}
}
for (int i = 1; i <= n; i++) ans = (ans + dp[l][i][0] + dp[l][i][1]) % MOD;
}
int main() {
scanf("%d%d", &n, &l);
for (int i = 1; i <= n; i++) scanf("%d%d", &A[i], &B[i]);
work();
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int const M = 1e9 + 7;
vector<int> a, b;
int dp[3001][100][2], n, l;
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) {
int h, w;
scanf("%d%d", &h, &w);
a.push_back(h);
b.push_back(w);
}
for (int i = 0; i < n; ++i) {
++dp[a[i]][i][0];
if (a[i] != b[i]) ++dp[b[i]][i][1];
}
for (int i = 1; i <= l; ++i) {
for (int j = 0; j < n; ++j) {
for (int t = 0; t < 2; ++t) {
for (int k = 0; k < n; ++k) {
if (k == j) continue;
if (t == 0) {
if (i - a[k] > 0 && a[k] == b[j])
dp[i][k][0] = (dp[i][k][0] % M + dp[i - a[k]][j][0] % M) % M;
if (a[k] != b[k] && i - b[k] > 0 && b[k] == b[j])
dp[i][k][1] = (dp[i][k][1] % M + dp[i - b[k]][j][0] % M) % M;
} else {
if (i - a[k] > 0 && a[k] == a[j])
dp[i][k][0] = (dp[i][k][0] % M + dp[i - a[k]][j][1] % M) % M;
if (a[k] != b[k] && i - b[k] > 0 && b[k] == a[j])
dp[i][k][1] = (dp[i][k][1] % M + dp[i - b[k]][j][1] % M) % M;
}
}
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i)
for (int t = 0; t < 2; ++t) ans = (ans % M + dp[l][i][t] % M) % M;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxix = 3000 + 10;
pair<int, int> arr[110];
int dp[maxix][110][2];
const int mod = 1000 * 1000 * 1000 + 7;
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
int finalans = 0;
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (arr[j].first == i)
dp[i][j][0] = 1;
else if (k != j && i - arr[j].first >= 0) {
if (arr[k].first == arr[j].first)
dp[i][j][0] = (dp[i][j][0] + dp[i - arr[j].first][k][1]) % mod;
else if (arr[k].second == arr[j].first)
dp[i][j][0] = (dp[i][j][0] + dp[i - arr[j].first][k][0]) % mod;
}
if (arr[j].second == i)
dp[i][j][1] = 1;
else if (k != j && i - arr[j].second >= 0) {
if (arr[k].first == arr[j].second)
dp[i][j][1] = (dp[i][j][1] + dp[i - arr[j].second][k][1]) % mod;
else if (arr[k].second == arr[j].second)
dp[i][j][1] = (dp[i][j][1] + dp[i - arr[j].second][k][0]) % mod;
}
}
}
}
for (int i = 0; i < n; i++) {
if (arr[i].first != arr[i].second)
finalans = (finalans + ((dp[l][i][0] + dp[l][i][1]) % mod)) % mod;
else
finalans = (finalans + max(dp[l][i][1], dp[l][i][0])) % mod;
}
cout << finalans % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = (1e9) + 7;
long long dp[3001][203];
vector<pair<int, int> > board;
vector<int> bi[101];
int N, L;
void modadd(long long& a, long long b) { a = (a + b) % mod; }
int main() {
scanf("%d %d", &N, &L);
for (int i = 0; i < N; i++) {
int w, l;
scanf("%d %d", &w, &l);
board.emplace_back(w, l);
bi[w].push_back(i);
if (w != l) bi[l].push_back(i);
}
for (int i = 0; i < N; i++) {
if (board[i].first <= L) dp[board[i].first][i << 1]++;
if (board[i].first != board[i].second && board[i].second <= L) {
dp[board[i].second][i << 1 | 1]++;
}
}
for (int len = 1; len < L; len++) {
for (int i = 0; i < N << 1; i++) {
int prevw = i % 2 == 1 ? board[i >> 1].first : board[i >> 1].second;
for (int j = 0; j < N; j++) {
if (i >> 1 == j) continue;
if (board[j].first == prevw && len + board[j].first <= L) {
modadd(dp[len + board[j].first][j << 1], dp[len][i]);
}
if (board[j].first != board[j].second && board[j].second == prevw &&
len + board[j].second <= L) {
modadd(dp[len + board[j].second][j << 1 | 1], dp[len][i]);
}
}
}
}
long long ret = 0;
for (int i = 0; i < N << 1; i++) {
modadd(ret, dp[L][i]);
}
printf("%lld", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Fence {
long long leng, wei;
};
long long n, l, ans;
Fence fence[2005];
long long dp[2005][3005][2];
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> fence[i].leng >> fence[i].wei;
for (int j = 1; j <= l; j++) {
for (int i = 0; i < n; i++) {
if (j > fence[i].leng) {
for (int k = 0; k < n; k++) {
if (k == i) continue;
if (fence[i].leng == fence[k].wei)
dp[i][j][1] += dp[k][j - fence[i].leng][1],
dp[i][j][1] %= 1000000007;
if (fence[i].leng == fence[k].leng)
dp[i][j][1] += dp[k][j - fence[i].leng][0],
dp[i][j][1] %= 1000000007;
}
}
if (j > fence[i].wei && fence[i].leng != fence[i].wei) {
for (int k = 0; k < n; k++) {
if (k == i) continue;
if (fence[i].wei == fence[k].wei)
dp[i][j][0] += dp[k][j - fence[i].wei][1],
dp[i][j][0] %= 1000000007;
if (fence[i].wei == fence[k].leng)
dp[i][j][0] += dp[k][j - fence[i].wei][0],
dp[i][j][0] %= 1000000007;
}
}
if (j == fence[i].leng) dp[i][j][1]++;
if (j == fence[i].wei && fence[i].leng != fence[i].wei) dp[i][j][0]++;
}
}
for (int i = 0; i < n; i++)
ans += dp[i][l][1] + dp[i][l][0], ans %= 1000000007;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mas[101][3001][2];
pair<int, int> p[101];
vector<vector<int>> lst;
int main() {
int n, l;
cin >> n >> l;
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
p[i] = make_pair(a, b);
mas[i][p[i].first][0] = 1;
if (p[i].first != p[i].second) mas[i][p[i].second][1] = 1;
}
for (int i = 0; i < n; i++) {
vector<int> k;
for (int j = 0; j < n; j++) {
if (i != j && (p[i].first == p[j].first || p[i].first == p[j].second ||
p[i].second == p[j].first || p[i].second == p[j].second)) {
k.push_back(j);
}
}
lst.push_back(k);
}
int k;
for (int i = 0; i <= l; i++) {
for (int j = 0; j < n; j++) {
for (int z = 0; z < 2; z++) {
if (mas[j][i][z] > 0) {
if (z == 0)
k = p[j].second;
else
k = p[j].first;
for (vector<int>::iterator t = lst[j].begin(); t < lst[j].end();
t++) {
if (k == p[*t].first) {
if (i + p[*t].first <= l)
mas[*t][i + p[*t].first][0] =
(mas[*t][i + p[*t].first][0] + mas[j][i][z]) % 1000000007;
} else if (k == p[*t].second) {
if (i + p[*t].second <= l) {
mas[*t][i + p[*t].second][1] =
(mas[*t][i + p[*t].second][1] + mas[j][i][z]) % 1000000007;
}
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + mas[i][l][0]) % 1000000007;
ans = (ans + mas[i][l][1]) % 1000000007;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
void solve() {
long long int n, a, l, b;
cin >> n >> l;
vector<pair<long long int, long long int>> store;
for (long long int i = 0; i < n; i++) {
cin >> a >> b;
store.push_back({a, b});
}
vector<vector<vector<long long int>>> dp(
l + 2,
vector<vector<long long int>>(n + 2, vector<long long int>(102, 0)));
for (long long int i = 0; i < n; i++) {
a = store[i].first;
b = store[i].second;
if (a != b) {
if (a <= l) {
dp[a][i][b]++;
}
if (b <= l) {
dp[b][i][a]++;
}
} else {
if (a <= l) {
dp[a][i][a]++;
}
}
}
for (long long int i = 1; i <= l; i++) {
for (long long int j = 0; j < n; j++) {
a = store[j].first;
b = store[j].second;
for (long long int k = 0; k < n; k++) {
if (k == j) {
continue;
}
long long int val = i - a;
if (val > 0) {
dp[i][j][b] += dp[val][k][a];
dp[i][j][b] %= MOD;
}
if (b != a) {
val = i - b;
if (val > 0) {
dp[i][j][a] += dp[val][k][b];
dp[i][j][a] %= MOD;
}
}
}
}
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
a = store[i].first;
b = store[i].second;
ans += dp[l][i][a];
ans %= MOD;
if (a != b) {
ans += dp[l][i][b];
ans %= MOD;
}
}
cout << ans << "\n";
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, M = 3010, mod = 1e9 + 7;
int f[M][N][2], a[N], b[N];
int main() {
int n, m, ans = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (i == a[j]) f[i][j][0] = 1;
if (a[j] != b[j] && i == b[j]) f[i][j][1] = 1;
for (int k = 1; k <= n; k++) {
if (j == k) continue;
if (i >= a[j] && a[j] == a[k] && a[k] != b[k])
f[i][j][0] = (f[i][j][0] + f[i - a[j]][k][1]) % mod;
if (i >= a[j] && a[j] == b[k])
f[i][j][0] = (f[i][j][0] + f[i - a[j]][k][0]) % mod;
if (i < b[j] || a[j] == b[j]) continue;
if (b[j] == a[k] && a[k] != b[k])
f[i][j][1] = (f[i][j][1] + f[i - b[j]][k][1]) % mod;
if (b[j] == b[k]) f[i][j][1] = (f[i][j][1] + f[i - b[j]][k][0]) % mod;
}
}
}
for (int i = 1; i <= n; i++) {
ans = (ans + f[m][i][0]) % mod;
if (a[i] != b[i]) ans = (ans + f[m][i][1]) % mod;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
int a[205], b[205];
long long f[3005][205];
int main() {
scanf("%d%d", &n, &l);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
f[a[i]][i]++;
if (a[i] != b[i]) {
a[i + n] = b[i];
b[i + n] = a[i];
f[a[i + n]][i + n]++;
}
}
for (int i = 1; i <= l; i++)
for (int j = 1; j <= 2 * n; j++) {
if (!f[i][j]) continue;
for (int k = 1; k <= 2 * n; k++) {
if (j % n == k % n || b[j] != a[k]) continue;
if (i + a[k] > l) continue;
f[i + a[k]][k] = (f[i + a[k]][k] + f[i][j]) % 1000000007;
}
}
long long ans = 0;
for (int i = 1; i <= 2 * n; i++) ans = (ans + f[l][i]) % 1000000007;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
void solution() {
int n, l;
cin >> n >> l;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
int dp[l + 1][101][n];
for (int i = 0; i <= l; i++) {
for (int j = 0; j <= 100; j++) {
for (int q = 0; q < n; q++) {
dp[i][j][q] = 0;
}
}
}
for (int i = 0; i < n; i++) {
if (a[i] <= l) dp[a[i]][b[i]][i]++;
if (b[i] <= l && a[i] != b[i]) dp[b[i]][a[i]][i]++;
}
for (int cur_len = 1; cur_len < l; cur_len++) {
for (int last_height = 1; last_height <= 100; last_height++) {
for (int last_type = 0; last_type < n; last_type++) {
if (dp[cur_len][last_height][last_type] == 0) {
continue;
}
for (int i = 0; i < n; i++) {
if (i == last_type) continue;
if (last_height == b[i]) {
if (cur_len + b[i] <= l) {
dp[cur_len + b[i]][a[i]][i] +=
dp[cur_len][last_height][last_type];
dp[cur_len + b[i]][a[i]][i] %= mod;
}
}
if (last_height == a[i] && a[i] != b[i]) {
if (cur_len + a[i] <= l) {
dp[cur_len + a[i]][b[i]][i] +=
dp[cur_len][last_height][last_type];
dp[cur_len + a[i]][b[i]][i] %= mod;
}
}
}
}
}
}
int answer = 0;
for (int last_height = 1; last_height <= 100; last_height++) {
for (int last_type = 0; last_type < n; last_type++) {
answer = (answer + dp[l][last_height][last_type]) % mod;
}
}
cout << answer << "\n";
}
void include_file() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int main() {
solution();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int ans = 0;
int n, l, dp[105][3105][5];
vector<pair<int, int> > boards;
long long int solve(int prevIndex, int currTotalLength, int isRotated);
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
boards.push_back(make_pair(a, b));
}
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
if (boards[i].first != boards[i].second) {
ans += solve(i, boards[i].first, 0);
ans += solve(i, boards[i].second, 1);
} else
ans += solve(i, boards[i].first, 0);
}
cout << ans % 1000000007 << endl;
return 0;
}
long long int solve(int currIndex, int currTotalLength, int isRotated) {
if (currTotalLength > l) return 0;
if (currTotalLength == l) return 1;
if (dp[currIndex][currTotalLength][isRotated] != -1) {
return dp[currIndex][currTotalLength][isRotated];
}
long long int counter = 0;
for (int i = 0; i < n; i++) {
if (i != currIndex) {
if (boards[i].first != boards[i].second) {
if (isRotated == 0) {
if (boards[i].first == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].first, 0);
else if (boards[i].second == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].second, 1);
} else {
if (boards[i].first == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].first, 0);
else if (boards[i].second == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].second, 1);
}
} else {
if (isRotated == 0) {
if (boards[i].first == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].first, 0);
} else {
if (boards[i].first == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].first, 0);
}
}
}
}
return dp[currIndex][currTotalLength][isRotated] = counter % 1000000007;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[110][2][3010];
int wood[100][2];
int n, total_len;
long long sum(long long a, long long b) {
return ((a % 1000000007LL) + (b % 1000000007LL)) % 1000000007LL;
}
long long f(int type, int idfixed, int falta) {
int lenfix = wood[type][idfixed];
if (falta < 0) return 0LL;
long long& ans = dp[type][idfixed][falta];
if (falta == 0) return 1LL;
if (ans != -1LL) return ans;
ans = 0LL;
for (int i = (int)0; i < (int)n; i++)
if (i != type) {
for (int id = (int)0; id < (int)2; id++)
if (wood[i][id] == lenfix) {
ans = sum(ans, f(i, 1 - id, falta - lenfix));
if (lenfix == wood[i][1 - id]) break;
}
}
return ans;
}
int main() {
cin >> n >> total_len;
for (int i = (int)0; i < (int)n; i++) cin >> wood[i][0] >> wood[i][1];
memset(dp, -1, sizeof dp);
long long ans = 0;
for (int i = (int)0; i < (int)n; i++) {
ans = sum(ans, f(i, 0, total_len - wood[i][1]));
if (wood[i][1] == wood[i][0]) continue;
ans = sum(ans, f(i, 1, total_len - wood[i][0]));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
long long ans;
int a[230], b[230];
long long dp[3209][230];
int main() {
int i, j, k;
while (scanf("%d%d", &n, &l) != EOF) {
ans = 0;
memset(dp, 0, sizeof(dp));
for (i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
dp[a[i]][i]++;
if (a[i] != b[i]) {
a[i + n] = b[i];
b[i + n] = a[i];
dp[a[i + n]][i + n]++;
}
}
for (i = 1; i <= l; i++) {
for (j = 0; j < 2 * n; j++) {
if (!dp[i][j]) continue;
for (k = 0; k < 2 * n; k++) {
if (j % n != k % n && b[j] == a[k])
dp[i + a[k]][k] = (dp[i + a[k]][k] + dp[i][j]) % 1000000007;
}
}
}
for (i = 0; i < 2 * n; i++) ans = (ans + dp[l][i]) % 1000000007;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;
map<int, set<int> > M;
vector<pair<int, int> > V;
const int MOD = 1000000007;
int l;
int index(int i, int v) { return ((V[i].first == v) ? 0 : 1); }
int other(int i, int v) {
return ((V[i].first == v) ? V[i].second : V[i].first);
}
int main() {
ios::sync_with_stdio(false);
cout.precision(20);
int n;
cin >> n >> l;
vector<vector<vector<int> > > dp(l + 1,
vector<vector<int> >(n, vector<int>(2, 0)));
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
V.push_back(make_pair(a, b));
M[a].insert(i);
M[b].insert(i);
if (a <= l) dp[a][i][0] = 1;
if (a != b && b <= l) dp[b][i][1] = 1;
}
for (int i = 1; i < l; ++i) {
for (int j = 0; j < n; j++) {
for (int h = 0; h < 2; h++) {
if (dp[i][j][h] > 0) {
int x = (h == 0) ? V[j].second : V[j].first;
if (x + i <= l) {
for (int m : M[x]) {
if (m != j) {
dp[i + x][m][index(m, x)] += dp[i][j][h];
dp[i + x][m][index(m, x)] %= MOD;
}
}
}
}
}
}
}
int result = 0;
for (int i = 0; i < n; ++i) {
result += dp[l][i][0];
result %= MOD;
result += dp[l][i][1];
result %= MOD;
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<char, vector<char>, greater<char> > pq;
double startTime;
double getCurrentTime() {
return ((double)clock() - startTime) / CLOCKS_PER_SEC;
}
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int power(long long int x, unsigned long long int y,
long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int a[205], b[205], dp[250][3005];
long long int mod = 1e9 + 7;
long long int n;
long long int solve(long long int l, long long int i) {
if (dp[i][l] != -1) return dp[i][l];
if (l == 0) return 0;
long long int j, ans = 0;
for (j = 1; j <= 2 * n; j++) {
if (a[j] == -1 || (i != 0 && (j == i || j == i + n || j == i - n)))
continue;
if (i == 0 || a[j] == b[i]) {
if (a[j] < l)
ans = (ans + solve(l - a[j], j)) % mod;
else if (a[j] == l)
ans = (ans + 1) % mod;
}
}
dp[i][l] = ans;
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int l;
cin >> n >> l;
for (long long int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
a[i + n] = b[i];
b[i + n] = a[i];
if (a[i] == b[i]) a[i + n] = -1;
}
memset(dp, -1, sizeof(dp));
cout << solve(l, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
const double pi = 3.14159265358979323;
const double eps = 1e-8;
const int mod = 1000000007;
int n, L;
int tot;
bool Link[250][250];
pair<int, int> board[250];
int dp[3100][250];
int main() {
ios::sync_with_stdio(false);
int a, b;
cin >> n >> L;
memset(Link, false, sizeof(Link));
for (int i = (1); i < (n + 1); i++) {
cin >> a >> b;
board[i] = make_pair(a, b);
if (a != b)
board[i + n] = make_pair(b, a);
else
board[i + n] = make_pair(-1, -1);
}
for (int i = (1); i < (n + n + 1); i++)
for (int j = (1); j < (n + n + 1); j++)
if (i != j && i + n != j && j + n != i) {
if (board[i].second == board[j].first) Link[i][j] = true;
}
for (int i = (1); i < (n + n + 1); i++) Link[0][i] = true;
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
int tmp;
for (int i = (1); i < (L + 1); i++) {
for (int j = (1); j < (n + n + 1); j++)
if (board[j].first > 0 && i - board[j].first >= 0) {
tmp = i - board[j].first;
for (int k = (0); k < (n + n + 1); k++)
if (Link[k][j] && dp[tmp][k] > 0) {
dp[i][j] += dp[tmp][k];
if (dp[i][j] >= mod) dp[i][j] -= mod;
}
}
}
int ans = 0;
for (int i = (1); i < (n + n + 1); i++)
if (dp[L][i] > 0) {
ans += dp[L][i];
if (ans >= mod) ans -= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 230;
const int M = 3500;
int m, n;
int a[N], b[N];
long long dp[M][N];
int main() {
cin >> m >> n;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < m; ++i) {
cin >> a[i] >> b[i];
dp[a[i]][i]++;
if (a[i] != b[i]) {
a[i + m] = b[i];
b[i + m] = a[i];
dp[a[i + m]][i + m]++;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < m * 2; ++j) {
if (!dp[i][j]) continue;
for (int k = 0; k < 2 * m; ++k) {
if (j % m != k % m && a[k] == b[j])
dp[i + a[k]][k] = (dp[i + a[k]][k] + dp[i][j]) % inf;
}
}
}
long long ans = 0;
for (int i = 0; i < 2 * m; ++i) ans = (ans + dp[n][i]) % inf;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
int f[3005][205];
int length[205], width[205], c[205];
int n, L, tot;
int main() {
scanf("%d%d", &n, &L);
memset(f, 255, sizeof(f));
tot = n;
for (int i = 0; i < n; i++) {
scanf("%d%d", &length[i], &width[i]);
if (length[i] != width[i]) {
length[tot] = width[i];
width[tot] = length[i];
c[tot] = i;
f[length[tot]][tot] = 1;
tot++;
}
f[length[i]][i] = 1;
c[i] = i;
}
for (int l = 1; l <= L; l++)
for (int i = 0; i < tot; i++) {
if (l > length[i]) {
long long temp = 0;
for (int j = 0; j < tot; j++)
if (width[j] == length[i] && c[j] != c[i] &&
f[l - length[i]][j] != -1)
temp = (temp + f[l - length[i]][j]) % 1000000007;
f[l][i] = temp % 1000000007;
}
}
long long ans = 0;
for (int i = 0; i < tot; i++)
if (f[L][i] != -1) ans = (ans + f[L][i]) % 1000000007;
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
long long int memo[105][2][3005];
pair<int, int> type[105];
long long int dp(const int i, const bool d, const int j) {
if (j < 0) return 0LL;
if (memo[i][d][j] != -1) return memo[i][d][j];
long long int ans = 0;
int prev_wid = d ? type[i].first : type[i].second;
for (int k = 0; k < n; ++k) {
if (k == i) continue;
pair<int, int> tmp = type[k];
if (tmp.first == prev_wid)
ans = (ans + dp(k, false, j - prev_wid)) % 1000000007LL;
else if (tmp.second == prev_wid)
ans = (ans + dp(k, true, j - prev_wid)) % 1000000007LL;
}
return memo[i][d][j] = ans;
}
inline void init(void) {
memset(memo, 0xFF, sizeof memo);
for (int i = 0; i < 105; ++i) memo[i][0][0] = memo[i][1][0] = 1LL;
}
int main(void) {
init();
scanf("%d%d", &n, &l);
for (int i = 0, x, y; i < n; ++i) {
scanf("%d%d", &x, &y);
type[i] = pair<int, int>(x, y);
}
long long int ans = 0;
for (int i = 0; i < n; ++i) {
ans = (ans + dp(i, true, l - type[i].second)) % 1000000007LL;
if (type[i].first != type[i].second)
ans = (ans + dp(i, false, l - type[i].first)) % 1000000007LL;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxl = 3005;
const int Maxn = 105;
const int mod = 1000000007;
int n, l;
int a[Maxn], b[Maxn];
int ways[Maxl][Maxn][2];
int res;
int main() {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; i++) scanf("%d %d", &a[i], &b[i]);
for (int i = 0; i < n; i++) {
if (a[i] <= l) ways[a[i]][i][0]++;
if (a[i] != b[i] && b[i] <= l) ways[b[i]][i][1]++;
}
for (int i = 1; i < l; i++)
for (int j = 0; j < n; j++)
for (int c = 0; c < 2; c++) {
int need = c ? a[j] : b[j];
if (i + need > l) continue;
for (int k = 0; k < n; k++)
if (j != k)
if (a[k] == need)
ways[i + need][k][0] =
(ways[i + need][k][0] + ways[i][j][c]) % mod;
else if (b[k] == need)
ways[i + need][k][1] =
(ways[i + need][k][1] + ways[i][j][c]) % mod;
}
for (int j = 0; j < n; j++)
for (int c = 0; c < 2; c++) res = (res + ways[l][j][c]) % mod;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > woods;
int n, l;
long long memo[105][105][3005];
long long solve(int i, int width, int length) {
if (i == n || length > l) return 0;
if (length == l) return 1;
if (memo[i][width][length] != -1) return memo[i][width][length];
long long ans = 0;
for (int a = 0; a < n; a++) {
ans %= 1000000007;
if (a != i)
if (woods[a].first == width)
ans += solve(a, woods[a].second, length + woods[a].first);
else if (woods[a].second == width)
ans += solve(a, woods[a].first, length + woods[a].second);
}
return memo[i][width][length] = ans;
}
int main(int argc, const char* argv[]) {
memset(memo, -1, sizeof(memo));
cin >> n >> l;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
woods.push_back(make_pair(a, b));
}
long long ret = 0;
for (int i = 0; i < n; i++) {
ret += solve(i, woods[i].first, woods[i].second);
if (woods[i].first != woods[i].second)
ret += solve(i, woods[i].second, woods[i].first);
}
cout << ret % 1000000007 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long base = 1e9 + 7, dp[3010][110][2] = {0}, a[110], b[110], sum = 0;
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
for (int i = 0; i < n; ++i) {
dp[a[i]][i][0] = 1LL;
if (a[i] != b[i]) dp[b[i]][i][1] = 1LL;
}
for (int i = 0; i < l; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < 2; ++k)
if (!dp[i][j][k])
continue;
else {
int x = a[j];
int y = b[j];
if (k) swap(x, y);
if (x == y && k == 1) continue;
for (int _j = 0; _j < n; ++_j)
if (_j == j)
continue;
else
for (int _k = 0; _k < 2; ++_k) {
int _x = a[_j];
int _y = b[_j];
if (_k) swap(_x, _y);
if (_x == _y && _k == 1) continue;
if (_x == y && i + _x <= l)
dp[i + _x][_j][_k] += dp[i][j][k], dp[i + _x][_j][_k] %= base;
}
}
for (int i = 0; i < n; i++) sum += (dp[l][i][0] + dp[l][i][1]), sum %= base;
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long int MOD = 1000000007;
int N, L;
int width[100], height[100];
long long int DP[100][2][3001];
long long int dp(int i, int o, int len) {
long long int& ans = DP[i][o][len];
if (ans != -1) return ans;
int w = width[i], h = height[i];
if (o == 1) swap(w, h);
if (w > len) return 0;
if (len == w) return ans = 1;
ans = 0;
for (int j = 0; j <= N - 1; ++j) {
if (i == j) continue;
if (width[j] == h) {
ans = (ans + dp(j, 0, len - w)) % MOD;
}
if (width[j] != height[j] and height[j] == h) {
ans = (ans + dp(j, 1, len - w)) % MOD;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N >> L;
for (int i = 0; i <= N - 1; ++i) cin >> width[i] >> height[i];
memset(DP, -1, sizeof DP);
long long int ways = 0;
for (int i = 0; i <= N - 1; ++i) {
ways = (ways + dp(i, 0, L)) % MOD;
if (width[i] != height[i]) {
ways = (ways + dp(i, 1, L)) % MOD;
}
}
cout << ways << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105, maxl = 3005, mod = 1e9 + 7;
int f[maxl][maxn][2], a[maxn][2], n, l;
int main() {
scanf("%d%d", &n, &l);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i][0], &a[i][1]);
for (int i = 1; i <= l; i++)
for (int j = 1; j <= n; j++) {
if (i == a[j][0]) f[i][j][0] = 1;
if (i == a[j][1] and a[j][1] != a[j][0]) f[i][j][1] = 1;
for (int k = 1; k <= n; k++) {
if (j == k) continue;
if (a[j][0] <= i and a[j][0] == a[k][1])
f[i][j][0] = (f[i][j][0] + f[i - a[j][0]][k][0]) % mod;
if (a[j][0] <= i and a[j][0] == a[k][0] and a[k][0] != a[k][1])
f[i][j][0] = (f[i][j][0] + f[i - a[j][0]][k][1]) % mod;
if (a[j][0] != a[j][1]) {
if (a[j][1] <= i and a[j][1] == a[k][1])
f[i][j][1] = (f[i][j][1] + f[i - a[j][1]][k][0]) % mod;
if (a[j][1] <= i and a[j][1] == a[k][0] and a[k][0] != a[k][1])
f[i][j][1] = (f[i][j][1] + f[i - a[j][1]][k][1]) % mod;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + f[l][i][0]) % mod;
if (a[i][0] != a[i][1]) ans = (ans + f[l][i][1]) % mod;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e2, MOD = 1e9 + 7;
using namespace std;
int n, l, A[N + 9], B[N + 9], mem[109][3009][3];
int add(int a, int b) {
int s = (a >= MOD ? a - MOD : a) + (b >= MOD ? b - MOD : b);
return (s >= MOD ? s - MOD : s);
}
int solve(int last = 0, int len = 0, bool is_rot = 0) {
if (len > l) return 0;
if (len == l) return 1;
int &ret = mem[last][len][is_rot];
if (~ret) return ret;
ret = 0;
for (int j = 1; j <= n; ++j) {
if (j == last) continue;
if (!last)
ret =
add(ret, solve(j, A[j], 0) + (A[j] != B[j] ? solve(j, B[j], 1) : 0));
else if (!is_rot && A[j] == B[last])
ret = add(ret, (len + A[j] <= l ? solve(j, len + A[j], 0) : 0));
else if (!is_rot && B[j] == B[last])
ret = add(ret, (len + B[j] <= l ? solve(j, len + B[j], 1) : 0));
else if (is_rot && A[j] == A[last])
ret = add(ret, (len + A[j] <= l ? solve(j, len + A[j], 0) : 0));
else if (is_rot && B[j] == A[last])
ret = add(ret, (len + B[j] <= l ? solve(j, len + B[j], 1) : 0));
}
return ret;
}
int main() {
memset(mem, -1, sizeof mem);
scanf("%d %d", &n, &l);
for (int i = 1; i <= n; ++i) scanf("%d%d", &A[i], &B[i]);
printf("%d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 0x3f3f3f3f;
int n, k, M = 1e9 + 7;
pair<int, int> arr[101];
ll dp[101][101][3001];
ll solve(int lst, int t, int i) {
if (i > k) {
return 0;
}
if (i == k) {
return 1;
}
ll& ret = dp[lst][t][i];
if (~ret) {
return ret;
}
ret = 0;
for (int j = 0; j < n; ++j) {
if (j != t) {
if (arr[j].first == lst) {
ret += solve(arr[j].second, j, i + arr[j].second);
if (ret >= M) {
ret -= M;
}
} else if (arr[j].second == lst) {
ret += solve(arr[j].first, j, i + arr[j].first);
if (ret >= M) {
ret -= M;
}
}
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &arr[i].first, &arr[i].second);
}
ll ans = 0;
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; ++i) {
ans += solve(arr[i].first, i, arr[i].first);
if (ans >= M) {
ans -= M;
}
if (arr[i].first != arr[i].second) {
ans += solve(arr[i].second, i, arr[i].second);
}
if (ans >= M) {
ans -= M;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105, M = 502, INF = 1000 * 1000 * 1000 + 7;
const long double eps = 1e-10;
long double dist(pair<long double, long double> a,
pair<long double, long double> b) {
return sqrt((a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second));
}
unsigned long long z[N][2][3005];
int main() {
int n, l;
cin >> n >> l;
vector<vector<int>> a;
a.resize(n);
for (int i = 0; i < n; ++i) {
a[i].resize(2);
cin >> a[i][0] >> a[i][1];
}
for (int i = 0; i < n; ++i) {
z[i][0][a[i][0]] = 1;
z[i][1][a[i][1]] = 1;
}
for (int len = 1; len < l; len++) {
for (int i = 0; i < n; ++i) {
for (int type = 0; type < 2; ++type) {
if (type == 1 && a[i][0] == a[i][1]) continue;
if (!z[i][type][len]) continue;
z[i][type][len] %= INF;
for (int next = 0; next < n; ++next) {
if (next == i) continue;
for (int nextype = 0; nextype < 2; ++nextype) {
if (nextype == 1 && a[next][0] == a[next][1]) continue;
if (a[i][type ^ 1] == a[next][nextype]) {
z[next][nextype][len + a[next][nextype]] += z[i][type][len];
}
}
}
}
}
}
unsigned long long ans = 0;
for (int i = 0; i < n; ++i) {
for (int type = 0; type < 2; ++type) {
if (type == 1 && a[i][0] == a[i][1]) continue;
ans += z[i][type][l];
ans %= INF;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int p = 1e9 + 7;
using namespace std;
int main() {
int n, l;
cin >> n >> l;
int dp[n][l + 1], a[n][2], dp2[n][l + 1];
for (int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
for (int i = 0; i < n; i++)
for (int j = 0; j <= l; j++) dp[i][j] = dp2[i][j] = 0;
for (int j = 1; j <= l; j++)
for (int i = 0; i < n; i++) {
if (a[i][0] == j)
dp[i][j] += 1;
else if (a[i][0] < j) {
int s = -a[i][0] + j;
for (int k = 0; k < n; k++) {
if (i == k) continue;
if (a[k][1] == a[i][0]) {
dp[i][j] += dp[k][s];
dp[i][j] %= p;
} else if (a[k][0] == a[i][0]) {
dp[i][j] += dp2[k][s];
dp[i][j] %= p;
}
}
}
if (a[i][1] == a[i][0]) continue;
if (a[i][1] == j)
dp2[i][j] += 1;
else if (a[i][1] < j) {
int s = -a[i][1] + j;
for (int k = 0; k < n; k++) {
if (i == k) continue;
if (a[k][1] == a[i][1]) {
dp2[i][j] += dp[k][s];
dp2[i][j] %= p;
} else if (a[k][0] == a[i][1]) {
dp2[i][j] += dp2[k][s];
dp2[i][j] %= p;
}
}
}
}
int s = 0;
for (int i = 0; i < n; i++) {
s = (s + (dp[i][l] + dp2[i][l]) % p) % p;
}
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
vector<pair<pair<int, int>, int> > v;
long long int dp[201][3002];
int go(int pos, int l) {
if (l == 0) return 1;
if (l < 0) return 0;
long long int& res = dp[pos][l];
if (res != -1) return res;
res = 0;
for (int i = 0; i < v.size(); i++) {
if (v[pos].second == v[i].second) continue;
if (v[pos].first.second == v[i].first.first) {
res += go(i, l - v[i].first.first);
if (res >= 1000000007) res -= 1000000007;
}
}
return res;
}
int main() {
int n = nxt();
int l = nxt();
for (int i = 0; i < n; i++) {
int a = nxt();
int b = nxt();
v.push_back(make_pair(make_pair(a, b), i));
if (a != b) v.push_back(make_pair(make_pair(b, a), i));
}
memset(dp, -1, sizeof(dp));
long long int res = 0;
for (int i = 0; i < v.size(); i++)
res += go(i, l - v[i].first.first), res %= 1000000007;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[3001][101][2];
int n, l;
vector<pair<int, int> > v(101);
long long int calc(long long int len, long long int wid, long long int tr) {
if (len < 0) return 0;
if (len == 0) {
return 1;
}
if (dp[len][wid][tr] != -1) return dp[len][wid][tr];
long long int z = 0, kk;
if (tr == 0)
kk = v[wid].second;
else
kk = v[wid].first;
for (int i = 1; i <= n; i++) {
if (i == wid) continue;
if (len >= v[i].first && kk == v[i].first) {
z = (z + calc(len - v[i].first, i, 0)) % 1000000007;
}
if (len >= v[i].second && v[i].second == kk && v[i].first != v[i].second) {
z = (z + calc(len - v[i].second, i, 1)) % 1000000007;
}
}
dp[len][wid][tr] = z;
return z;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> l;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
cin >> v[i].first >> v[i].second;
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + calc(l - v[i].first, i, 0)) % 1000000007;
if (v[i].first != v[i].second)
ans = (ans + calc(l - v[i].second, i, 1)) % 1000000007;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sz, length;
const long long moduolo = 1e9 + 7;
vector<vector<int>> boards(100, vector<int>(2, 0));
vector<vector<vector<long long>>> DP(
2, vector<vector<long long>>(101, vector<long long>(1e4, -1)));
long long solve(int index, int so_far, bool f) {
f = !f;
if (DP[f][index][so_far] != -1) {
return DP[f][index][so_far];
}
if (so_far == length) {
return DP[f][index][so_far] = 1;
}
if (so_far > length) {
return DP[f][index][so_far] = 0;
}
if (index == sz) {
return DP[f][index][so_far] = 0;
}
long long ret = 0;
for (int i = 0; i < sz; i++) {
if (i == index) {
continue;
}
for (int j = 0; j < 2; j++) {
if (boards[index][f] == boards[i][j]) {
ret += solve(i, so_far + boards[i][j], j);
ret %= moduolo;
}
if (boards[i][0] == boards[i][1]) {
break;
}
}
}
return DP[f][index][so_far] = ret;
}
int main() {
cin >> sz >> length;
for (int i = 0; i < sz; i++) {
for (int j = 0; j < 2; j++) {
cin >> boards[i][j];
}
}
long long res = 0;
for (int i = 0; i < sz; i++) {
for (int j = 0; j < 2; j++) {
res += solve(i, boards[i][j], j);
res %= moduolo;
if (boards[i][0] == boards[i][1]) {
break;
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAX_N = 2e5, inf = 1e9, mod = 1e9 + 7;
long long int dp[3100][110][2] = {};
int32_t main() {
ios ::sync_with_stdio(0);
cin.tie(0);
long long int n, l;
cin >> n >> l;
long long int a[n + 2][2];
for (long long int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
for (long long int i = 0; i < n; i++) {
dp[a[i][0]][i][0]++;
if (a[i][0] != a[i][1]) dp[a[i][1]][i][1]++;
}
for (long long int i = 1; i <= l; i++) {
for (long long int j = 0; j < n; j++) {
for (long long int k = 0; k < 2; k++) {
if (k == 1 && a[j][0] == a[j][1]) continue;
for (long long int t = 0; t < n; t++) {
if (t == j) continue;
if (a[t][0] == a[j][k] && i >= a[j][k]) {
dp[i][j][k] += dp[i - a[j][k]][t][1];
dp[i][j][k] %= mod;
}
if (a[t][1] == a[j][k] && i >= a[j][k]) {
dp[i][j][k] += dp[i - a[j][k]][t][0];
dp[i][j][k] %= mod;
}
}
}
}
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
ans += dp[l][i][0] + dp[l][i][1];
ans %= mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[4000][200][3], a[200], b[200];
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
bool noAcheck, noBcheck;
noAcheck = noBcheck = false;
dp[i][j][0] = dp[i][j][1] = 0;
if (i - a[j] == 0) {
dp[i][j][0] = 1;
noAcheck = true;
}
if (a[j] != b[j] && i - b[j] == 0) {
dp[i][j][1] = 1;
noBcheck = true;
}
if (!noAcheck && i - a[j] > 0)
for (int k = 0; k < n; k++)
if (j != k)
if (a[j] == b[k]) {
dp[i][j][0] += dp[i - a[j]][k][0];
dp[i][j][0] %= 1000000007;
} else if (a[j] == a[k]) {
dp[i][j][0] += dp[i - a[j]][k][1];
dp[i][j][0] %= 1000000007;
}
if (a[j] == b[j]) continue;
if (!noBcheck && i - b[j] > 0)
for (int k = 0; k < n; k++)
if (j != k)
if (b[j] == b[k]) {
dp[i][j][1] += dp[i - b[j]][k][0] % 1000000007;
dp[i][j][1] %= 1000000007;
} else if (b[j] == a[k]) {
dp[i][j][1] += dp[i - b[j]][k][1] % 1000000007;
dp[i][j][1] %= 1000000007;
}
}
}
long long int ans = 0;
for (int i = 0; i < n; i++) ans += (dp[l][i][0] + dp[l][i][1]) % 1000000007;
cout << ans % 1000000007 << endl;
}
|
#include <bits/stdc++.h>
using std::abs;
using std::bitset;
using std::cerr;
using std::cin;
using std::copy;
using std::cout;
using std::deque;
using std::endl;
using std::fill;
using std::fixed;
using std::greater;
using std::iota;
using std::istream;
using std::lower_bound;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::multiset;
using std::next_permutation;
using std::nth_element;
using std::ostream;
using std::pair;
using std::priority_queue;
using std::queue;
using std::reverse;
using std::rotate;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::tie;
using std::tuple;
using std::unique;
using std::unordered_map;
using std::unordered_set;
using std::upper_bound;
using std::vector;
long long rnd(long long x, long long y) {
static auto gen = std::bind(std::uniform_int_distribution<long long>(),
std::mt19937(960172));
return gen() % (y - x + 1) + x;
}
long long gcd(long long a, long long b) {
while (b > 0) {
long long t = a % b;
a = b;
b = t;
}
return a;
}
template <typename T>
T sqr(T const& a) {
return a * a;
}
int const INF = 100 + (int)1e9;
long long const INFL = 100 + (long long)1e18;
long double const PI = 3.1415926535897932384626433832795028;
int const MOD = 1000000007;
void add(int& a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int n;
int mem[3030][111][2];
bool was[3030][111][2];
int a[2][111];
int go(int last, int rest, int rot) {
if (rest == 0) return 1;
int& ans = mem[rest][last][rot];
if (was[rest][last][rot]) return ans;
was[rest][last][rot] = true;
ans = 0;
for (int next = 0; next < n; ++next) {
if (next == last) continue;
for (int r = 0; r < 2; ++r) {
if (a[0][next] == a[1][next] && r == 1) continue;
if (a[!rot][last] != a[r][next]) continue;
if (a[r][next] > rest) continue;
add(ans, go(next, rest - a[r][next], r));
}
}
return ans;
}
void solve() {
int l;
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) {
scanf("%d%d", a[0] + i, a[1] + i);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (l >= a[0][i]) add(ans, go(i, l - a[0][i], 0));
if (l >= a[1][i] && a[0][i] != a[1][i]) add(ans, go(i, l - a[1][i], 1));
}
printf("%d\n", ans);
}
int main() {
cout.precision(15);
cout << fixed;
cerr.precision(6);
cerr << fixed;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long long int INF = 1000111000111000111LL;
const long long int MAX = 2e5 + 5;
const long double PI = 3.1415926536;
int32_t main() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int N, L;
cin >> N >> L;
pair<long long int, long long int> a[2 * N + 1];
long long int dp[3005][202];
bool visit[3005][202];
memset(dp, 0, sizeof dp);
memset(visit, false, sizeof visit);
for (long long int i = 1; i <= N; i++) {
cin >> a[i].first >> a[i].second;
dp[a[i].first][i]++;
visit[a[i].first][i] = true;
if (a[i].first == a[i].second) {
a[i + N].first = 3001;
a[i + N].second = 3001;
} else {
a[i + N].first = a[i].second;
a[i + N].second = a[i].first;
}
dp[a[i + N].first][i + N]++;
visit[a[i + N].first][i + N] = true;
}
for (long long int l = 1; l <= L - 1; l++) {
for (long long int i = 1; i <= 2 * N; i++) {
if (visit[l][i]) {
for (long long int j = 1; j <= 2 * N; j++) {
if (i == j or a[i].second != a[j].first) continue;
if (l + a[j].first > L) continue;
if (abs(i - j) == N) continue;
visit[l + a[j].first][j] = true;
dp[l + a[j].first][j] += dp[l][i];
dp[l + a[j].first][j] %= MOD;
}
}
}
}
long long int ans = 0;
for (long long int i = 1; i <= 2 * N; i++) {
ans += (dp[L][i]);
ans %= MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void input(long long int n, long long int a[]) {
for (long long int i = 0; i < n; ++i) cin >> a[i];
}
long long int bin_expo(long long int A, long long int B, long long int M) {
long long int result = 1ll;
while (B > 0) {
if (B % 2 == 1) {
result = (result * A) % M;
}
A = (A * A) % M;
B = B / 2;
}
return result;
}
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 lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int n, l;
long long int a[101], b[101];
long long int dp[4001][200][3];
long long int solve(long long int left, long long int prev,
long long int flag) {
if (left < 0) return 0LL;
if (left == 0) return 1LL;
if (dp[left][prev][flag] != -1) return dp[left][prev][flag];
long long int res = 0;
if (prev == -1) {
for (long long int i = 0; i < n; ++i) {
res += solve(left - a[i], i, 2);
if (a[i] != b[i]) res += solve(left - b[i], i, 1);
res %= 1000000007;
}
} else {
for (long long int i = 0; i < n; ++i) {
if (i != prev) {
long long int cur;
if (flag == 1) cur = a[prev];
if (flag == 2) cur = b[prev];
if (a[i] == cur)
res += solve(left - a[i], i, 2);
else if (b[i] == cur)
res += solve(left - b[i], i, 1);
res %= 1000000007;
}
}
}
return dp[left][prev][flag] = res % 1000000007;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> l;
for (long long int i = 0; i < n; ++i) cin >> a[i] >> b[i];
cout << solve(l, -1, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 120, MAXL = 3e3 + 20;
const long long P = 1e9 + 7;
int n;
long long w[MAXN], h[MAXN], d[MAXL][MAXN][2];
int main() {
int l;
scanf("%d%d", &n, &l);
for (int i = 0; i < n; i++) scanf("%d%d", &w[i], &h[i]);
for (int i = 1; i <= l; i++)
for (int j = 0; j < n; j++) {
if (w[j] == i) d[i][j][0] = 1;
if (w[j] != h[j] && h[j] == i) d[i][j][1] = 1;
for (int k = 0; k < n; k++) {
if (j == k) continue;
if (w[j] == h[k] && i >= w[j])
d[i][j][0] = (d[i][j][0] + d[i - w[j]][k][0]) % P;
if (w[j] == w[k] && i >= w[j])
d[i][j][0] = (d[i][j][0] + d[i - w[j]][k][1]) % P;
if (w[j] != h[j] && i >= h[j]) {
if (h[j] == h[k]) d[i][j][1] = (d[i][j][1] + d[i - h[j]][k][0]) % P;
if (h[j] == w[k]) d[i][j][1] = (d[i][j][1] + d[i - h[j]][k][1]) % P;
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) ans = (ans + d[l][i][0] + d[l][i][1]) % P;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[4010][100][2];
int a[100][2], n, l;
void add(long long &a, long long b) {
a += b;
if (a >= ((long long)1e9 + 7)) a -= ((long long)1e9 + 7);
}
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i][0], &a[i][1]);
if (a[i][0] <= l) dp[a[i][0]][i][0]++;
if (a[i][1] <= l && a[i][0] != a[i][1]) dp[a[i][1]][i][1]++;
}
for (int i = 1; i < l; i++)
for (int j = 0; j < n; j++) {
for (int k = 0; k < 2; k++) {
if (dp[i][j][k]) {
for (int x = 0; x < n; x++) {
if (x != j && a[x][0] == a[j][1 - k])
add(dp[i + a[x][0]][x][0], dp[i][j][k]);
if (x != j && a[x][1] != a[x][0] && a[x][1] == a[j][1 - k])
add(dp[i + a[x][1]][x][1], dp[i][j][k]);
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) add(ans, dp[l][i][j]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, l;
int len[109], wd[109];
int dp[3002][103][2];
int solve(int sum, int last, int typ) {
if (sum == l) return 1;
if (sum > l) return 0;
int &ret = dp[sum][last][typ];
if (ret != (-1)) return ret;
ret = 0;
for (int i = 1; i <= n; i++) {
if (i == last) continue;
if (last == 0) {
if (len[i] != wd[i]) {
ret += solve(sum + len[i], i, 0), ret = ret % mod;
ret += solve(sum + wd[i], i, 1), ret = ret % mod;
} else {
ret += solve(sum + len[i], i, 0);
ret = ret % mod;
}
} else {
int pre;
if (typ == 0) {
pre = wd[last];
} else if (typ == 1) {
pre = len[last];
}
if (len[i] != wd[i]) {
if (pre == len[i]) ret += solve(sum + len[i], i, 0), ret = ret % mod;
if (pre == wd[i]) ret += solve(sum + wd[i], i, 1), ret = ret % mod;
} else {
if (pre == len[i]) ret += solve(sum + len[i], i, 0), ret = ret % mod;
}
}
}
if (ret < 0) ret += mod;
ret = ret % mod;
return ret;
}
int main() {
scanf("%d%d", &n, &l);
memset(dp, -1, sizeof dp);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &len[i], &wd[i]);
}
int ses = solve(0, 0, 0);
printf("%d\n", ses);
return 0;
}
|
#include <bits/stdc++.h>
const int M = 1000000000 + 7;
int n, l, a[2][100];
int dp[30001][100][2], res = 0;
int main() {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; ++i) scanf("%d %d", &a[0][i], &a[1][i]);
for (int i = 1; i <= l; ++i)
for (int k = 0; k < n; ++k)
for (int p = 0; p < (a[0][k] == a[1][k] ? 1 : 2); ++p)
if (i == a[p][k])
dp[i][k][p] = 1;
else if (i > a[p][k]) {
dp[i][k][p] = 0;
for (int j = 0; j < n; ++j)
if (k != j)
for (int q = 0; q < 2; ++q)
if (a[(q + 1) % 2][j] == a[p][k])
dp[i][k][p] = (dp[i][k][p] + dp[i - a[p][k]][j][q]) % M;
}
for (int i = 0; i < n; ++i) res = (res + (dp[l][i][0] + dp[l][i][1]) % M) % M;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[3011][111][2], a[110], b[110], n, l, ans = 0;
long long base = 1e9 + 7;
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
for (int i = 0; i < n; i++) {
dp[a[i]][i][0] = 1;
if (a[i] != b[i]) dp[b[i]][i][1] = 1;
}
for (int i = 0; i < l; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++)
if (dp[i][j][k]) {
int x = a[j];
int y = b[j];
if (k == 1) swap(x, y);
if (x == y && k == 1) continue;
for (int _j = 0; _j < n; _j++)
if (j != _j)
for (int _k = 0; _k < 2; _k++) {
int _x = a[_j];
int _y = b[_j];
if (_k) swap(_x, _y);
if (_x == _y && _k == 1) continue;
if (_x == y && _x + i <= l)
dp[_x + i][_j][_k] += dp[i][j][k], dp[_x + i][_j][_k] %= base;
}
}
for (int i = 0; i < n; i++) ans += (dp[l][i][0] + dp[l][i][1]), ans %= base;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long mod = 1000000007;
using namespace std;
template <typename T>
void printV(vector<T>& v) {
for (int i = 0; i < (int)(v.size()); i++) cout << v[i] << " ";
cout << endl;
}
template <typename T>
void printVs(vector<vector<T> >& v) {
for (int i = 0; i < (int)(v.size()); i++) printV(v[i]);
}
const int N = 600000;
const char aa = 'a';
int gcd(int A, int B) {
if (A == 0 || B == 0) return A + B;
return gcd(B, A % B);
}
int numDiv(int A) {
int res = 1;
for (int i = 2; i <= A; i++)
if (A % i == 0) res++;
return res;
}
long long A[3001][100][2];
int main(int argc, const char* argv[]) {
memset(A, 0, sizeof(A));
int n, l;
cin >> n >> l;
vector<pair<int, int> > P(n);
for (int i = 0; i < (int)(n); i++) cin >> P[i].first >> P[i].second;
for (int len = 0; len < (int)(l + 1); len++)
for (int typ = 0; typ < (int)(n); typ++)
for (int dr = 0; dr < (int)(2); dr++) {
int W = P[typ].first;
int L = P[typ].second;
if (dr) swap(W, L);
if (L > len) {
A[len][typ][dr] = 0;
continue;
}
if (L == len) {
A[len][typ][dr] = 1;
continue;
}
for (int prev = 0; prev < (int)(n); prev++)
if (prev != typ)
if (P[prev].first == L || P[prev].second == L) {
int turn = (P[prev].first != L);
A[len][typ][dr] += A[len - L][prev][turn];
A[len][typ][dr] %= mod;
}
}
long long res = 0;
for (int typ = 0; typ < (int)(n); typ++) {
res += A[l][typ][0];
if (P[typ].first != P[typ].second) res += A[l][typ][1];
res %= mod;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int an[101][100][3001], p[101][3001], md = 1e9 + 7;
vector<pair<pair<int, int>, int> > bl;
int main() {
int n, l;
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
bl.push_back(make_pair(make_pair(a, b), i));
if (a != b) bl.push_back(make_pair(make_pair(b, a), i));
}
for (int i = 0; i < bl.size(); ++i)
an[bl[i].first.first][bl[i].second][bl[i].first.second] = 1,
++p[bl[i].first.first][bl[i].first.second];
for (int i = 1; i < l; ++i)
for (int j = 0; j < bl.size(); ++j) {
int w = bl[j].first.first, l = bl[j].first.second, id = bl[j].second;
if (i + l > 3000) continue;
int z = p[l][i] - an[l][id][i];
if (z >= md)
z -= md;
else if (z < 0)
z += md;
an[w][id][i + l] += z;
if (an[w][id][i + l] >= md) an[w][id][i + l] -= md;
p[w][i + l] += z;
if (p[w][i + l] >= md) p[w][i + l] -= md;
}
int an = 0;
for (int i = 0; i < 101; ++i) {
an += p[i][l];
if (an >= md) an -= md;
}
printf("%d\n", an);
}
|
#include <bits/stdc++.h>
using namespace std;
long long inv(int a, int p) {
return a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p;
}
static const int MODVAL = 1000000007;
struct mint {
int val;
mint() : val(0) {}
mint(int x) : val(x % MODVAL) {}
mint(size_t x) : val(x % MODVAL) {}
mint(long long x) : val(x % MODVAL) {}
mint& operator+=(mint y) {
val = (val + y.val) % MODVAL;
return *this;
}
mint& operator-=(mint y) {
val = (val - y.val + MODVAL) % MODVAL;
return *this;
}
mint& operator*=(mint y) {
val = ((long long)val * y.val) % MODVAL;
return *this;
}
mint& operator/=(mint y) {
val = (val * inv(y.val, MODVAL)) % MODVAL;
return *this;
}
};
inline mint operator+(mint x, mint y) { return x += y; }
inline mint operator-(mint x, mint y) { return x -= y; }
inline mint operator*(mint x, mint y) { return x *= y; }
inline mint operator/(mint x, mint y) { return x /= y; }
mint POW(mint x, long long n) {
mint r(1);
for (; n; x *= x, n >>= 1)
if (n & 1) r *= x;
return r;
}
mint FAC(int n) {
static vector<mint> FAC_(1, 1);
while (int(FAC_.size()) <= n) FAC_.push_back(FAC_.back() * FAC_.size());
return FAC_[n];
}
inline mint CMB(int n, int k) {
return k < 0 || n < k ? 0 : FAC(n) / (FAC(k) * FAC(n - k));
}
inline ostream& operator<<(ostream& os, mint a) { return os << a.val; }
int n;
int vs[101][2];
mint memo[101][2][3010];
bool visited[101][2][3010];
mint solve(int last, int dir, int rest) {
mint& res = memo[last][dir][rest];
if (visited[last][dir][rest]) return res;
visited[last][dir][rest] = true;
if (rest == 0) {
res = 1;
} else {
res = 0;
for (int i = 0; i < (int)(n); ++i) {
for (int d = 0; d < (int)(2); ++d) {
if (i == last) continue;
if (last != 100 && vs[last][1 ^ dir] != vs[i][d]) continue;
if (vs[i][d] > rest) continue;
if (d == 1 && vs[i][0] == vs[i][1]) continue;
res += solve(i, d, rest - vs[i][d]);
}
}
}
return res;
}
int main(void) {
int len;
scanf("%d%d", &n, &len);
for (int i = 0; i < (int)(n); ++i) {
scanf("%d%d", &vs[i][0], &vs[i][1]);
}
cout << solve(100, 0, len) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Id[2 * 105];
int L[2 * 105];
int W[2 * 105];
long long int dp[2 * 105][3005];
bool vis[2 * 105][3005];
int n, l;
long long int solve(int LastTp, int Len) {
if (Len > l) return 0LL;
if (Len == l) return 1LL;
if (vis[LastTp][Len] == 1) return dp[LastTp][Len];
vis[LastTp][Len] = 1;
long long int ret = 0;
for (int i = 1; i <= n; i++) {
if (Id[i] == Id[LastTp]) continue;
if (W[LastTp] == L[i]) ret = (ret + solve(i, Len + L[i])) % 1000000007;
}
return dp[LastTp][Len] = ret;
}
int main() {
int N, x, y;
scanf("%d %d", &N, &l);
for (int i = 1; i <= N; i++) {
scanf("%d %d", &x, &y);
L[++n] = x;
W[n] = y;
Id[n] = i;
if (x != y) {
L[++n] = y;
W[n] = x;
Id[n] = i;
}
}
long long int Sum = 0;
for (int i = 1; i <= n; i++) Sum = (Sum + solve(i, L[i])) % 1000000007;
cout << Sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod1 = 998244353;
long long mod = 1e9 + 7;
const long long N = 105;
vector<pair<long long, long long> > a;
long long n, l;
long long dp[3005][N][N];
void solve() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a.push_back(make_pair(min(x, y), max(x, y)));
}
memset(dp, 0, sizeof(dp));
int n1 = 104;
for (int i = 0; i < n; i++)
dp[0][a[i].first][n1] = 1, dp[0][a[i].second][n1] = 1;
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
if (i - a[j].second >= 0) {
dp[i][a[j].first][j] += mod + dp[i - a[j].second][a[j].second][n1] -
dp[i - a[j].second][a[j].second][j];
dp[i][a[j].first][j] %= mod;
}
if (a[j].second != a[j].first && i - a[j].first >= 0) {
dp[i][a[j].second][j] += mod + dp[i - a[j].first][a[j].first][n1] -
dp[i - a[j].first][a[j].first][j];
dp[i][a[j].second][j] %= mod;
}
}
for (int j = 0; j < n; j++) {
dp[i][a[j].second][n1] =
(dp[i][a[j].second][n1] + dp[i][a[j].second][j]) % mod;
if (a[j].second != a[j].first)
dp[i][a[j].first][n1] =
(dp[i][a[j].first][n1] + dp[i][a[j].first][j]) % mod;
}
}
long long ans = 0;
for (int j = 1; j < 102; j++) {
ans = (ans + dp[l][j][n1]) % mod;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int dp[3010][210];
struct node {
int l, r, id;
};
node x[210];
int main() {
int n, l;
while (scanf("%d%d", &n, &l) == 2) {
int cnt = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[cnt].l, &x[cnt].r);
cnt++;
x[cnt - 1].id = i;
;
if (x[cnt - 1].l != x[cnt - 1].r) {
x[cnt].l = x[cnt - 1].r;
x[cnt].r = x[cnt - 1].l;
x[cnt++].id = x[cnt - 1].id;
}
}
memset(dp, 0, sizeof(dp));
int ans = 0;
for (int i = 0; i < cnt; i++) dp[x[i].l][i] = 1;
for (int i = 0; i <= l; i++) {
for (int j = 0; j < cnt; j++) {
for (int k = 0; k < cnt; k++) {
if (i < x[j].l) continue;
if (x[k].r == x[j].l && x[k].id != x[j].id)
dp[i][j] = (dp[i - x[j].l][k] + dp[i][j]) % MOD;
}
}
}
for (int i = 0; i < cnt; i++) ans = (ans + dp[l][i]) % MOD;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
static const int INF = std::numeric_limits<int>::max();
int MOD = 1000000007;
int dp[3001][100][2];
int main() {
int n, L;
std::cin >> n >> L;
std::vector<int> a(n), b(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i] >> b[i];
}
dp[0][0][0] = 1;
for (int i = 0; i < L; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < 2; ++k) {
if (dp[i][j][k] == 0) continue;
int pre_width = k == 0 ? a[j] : b[j];
for (int l = 0; l < n; ++l) {
if (i > 0 && j == l) continue;
int width = a[l], length = b[l];
for (int m = 0; m < 2; ++m) {
if ((i == 0 || pre_width == length) && i + length <= L) {
dp[i + length][l][m] += dp[i][j][k];
dp[i + length][l][m] %= MOD;
}
if (width == length) break;
std::swap(width, length);
}
}
}
}
}
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2; ++j) {
res += dp[L][i][j];
res %= MOD;
}
}
std::cout << res << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
struct Node {
int length, width;
int type;
};
long long dp[3007][300];
int b[300][300];
Node a[205];
int n, l;
int main() {
int i, j, k, b, c;
memset(dp, 0, sizeof dp);
while (scanf("%d %d", &n, &l) != EOF) {
getchar();
int cnt = 0;
for (i = 1; i <= n; i++) {
cin >> b;
cin >> c;
a[++cnt].length = b;
a[cnt].width = c;
a[cnt].type = i;
dp[b][cnt] = 1;
if (b != c) {
cnt++;
a[cnt].length = c;
a[cnt].width = b;
a[cnt].type = i;
dp[c][cnt] = 1;
}
}
for (i = 1; i <= l; i++) {
for (j = 1; j <= cnt; j++) {
if (dp[i][j]) {
for (k = 1; k <= cnt; k++) {
if (a[j].type == a[k].type) {
continue;
}
if (a[j].width == a[k].length && (i + a[k].length <= l)) {
dp[i + a[k].length][k] += dp[i][j];
dp[i + a[k].length][k] %= MOD;
}
}
}
}
}
long long ans = 0;
for (i = 1; i <= cnt; i++) {
ans += dp[l][i];
ans %= MOD;
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int mod = (int)1e9 + 7;
int a[111][2], dp[3333][111][2];
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1];
}
for (int i = 0; i < n; i++) {
dp[a[i][0]][i][0]++;
if (a[i][0] != a[i][1]) {
dp[a[i][1]][i][1]++;
}
}
for (int i = 0; i < l; i++) {
for (int j = 0; j < n; j++) {
for (int jj = 0; jj < 2; jj++) {
for (int k = 0; k < n; k++) {
if (j == k) continue;
for (int kk = 0; kk < 2; kk++) {
if (kk == 1 && a[k][0] == a[k][1]) break;
if (a[j][jj ^ 1] == a[k][kk]) {
dp[i + a[k][kk]][k][kk] += dp[i][j][jj];
dp[i + a[k][kk]][k][kk] %= mod;
}
}
}
}
}
}
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
res += dp[l][i][j];
res %= mod;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int test = 1;
while (test--) {
long long int n, l;
cin >> n >> l;
pair<long long int, long long int> co[n];
for (int i = 0; i < n; i++) {
cin >> co[i].first >> co[i].second;
}
long long int dp[4005][n][2];
memset(dp, 0, sizeof dp);
for (int i = 0; i < n; i++) {
dp[co[i].first][i][0] = 1;
if (co[i].first != co[i].second) {
dp[co[i].second][i][1] = 1;
}
}
for (int i = 1; i < l; i++) {
for (int last = 0; last < n; last++) {
for (int cur = 0; cur < n; cur++) {
if (last == cur) {
continue;
}
if (co[last].second == co[cur].first) {
dp[i + co[cur].first][cur][0] += dp[i][last][0];
dp[i + co[cur].first][cur][0] %= 1000000007;
}
if (co[last].first == co[cur].first) {
dp[i + co[cur].first][cur][0] += dp[i][last][1];
dp[i + co[cur].first][cur][0] %= 1000000007;
}
if (co[last].first == co[cur].second &&
co[cur].first != co[cur].second) {
dp[i + co[cur].second][cur][1] += dp[i][last][1];
dp[i + co[cur].second][cur][1] %= 1000000007;
}
if (co[last].second == co[cur].second &&
co[cur].first != co[cur].second) {
dp[i + co[cur].second][cur][1] += dp[i][last][0];
dp[i + co[cur].second][cur][1] %= 1000000007;
}
}
}
}
long long int pr = 0;
for (int i = 0; i < n; i++) {
pr += dp[l][i][0];
pr += dp[l][i][1];
pr %= 1000000007;
}
cout << pr << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, l;
scanf("%d %d", &n, &l);
int a[n];
int b[n];
for (int i = 0; i < n; i++) {
scanf("%d %d", a + i, b + i);
}
int pole[l + 1][n];
int prevracene[l + 1][n];
for (int i = 0; i <= l; i++) {
for (int j = 0; j < n; j++) {
pole[i][j] = prevracene[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
if (b[i] <= l) {
pole[b[i]][i] = 1;
}
if (a[i] != b[i]) {
if (a[i] <= l) {
prevracene[a[i]][i] = 1;
}
}
}
int pocet;
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
pocet = pole[i][j];
for (int k = 0; k < n; k++) {
if (j != k) {
if ((b[j] == a[k]) && (i - b[j] >= 1)) {
pocet = (pocet + pole[i - b[j]][k]) % 1000000007;
}
if ((b[j] == b[k]) && (i - b[j] >= 1)) {
pocet = (pocet + prevracene[i - b[j]][k]) % 1000000007;
}
}
}
pole[i][j] = pocet;
if (a[j] != b[j]) {
pocet = prevracene[i][j];
for (int k = 0; k < n; k++) {
if (j != k) {
if ((a[j] == a[k]) && (i - a[j] >= 1)) {
pocet = (pocet + pole[i - a[j]][k]) % 1000000007;
}
if ((a[j] == b[k]) && (i - a[j] >= 1)) {
pocet = (pocet + prevracene[i - a[j]][k]) % 1000000007;
}
}
}
prevracene[i][j] = pocet;
}
}
}
int soucet = 0;
for (int i = 0; i < n; i++) {
soucet = (soucet + prevracene[l][i]) % 1000000007;
soucet = (soucet + pole[l][i]) % 1000000007;
}
printf("%d\n", soucet);
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[111];
long long int dp[105][105][3010];
int n, l;
long long int cal(int pre, int ind, int rem) {
if (rem == 0) return 1;
if (rem < 0) return 0;
long long int &ret = dp[pre][ind][rem];
if (ret != -1) return ret;
ret++;
for (int i = 0; i < n; i++) {
if (i == ind) continue;
if (a[i].second == pre) ret += cal(a[i].first, i, rem - a[i].second);
if (a[i].first == pre && a[i].first != a[i].second)
ret += cal(a[i].second, i, rem - a[i].first);
ret %= 1000000007;
}
return ret % 1000000007;
}
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].first, &a[i].second);
long long int ans = 0;
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++) {
ans += cal(a[i].first, i, l - a[i].second);
if (a[i].first != a[i].second) ans += cal(a[i].second, i, l - a[i].first);
ans %= 1000000007;
}
cout << ans % 1000000007;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[3001][101][3];
int a[101], b[101];
int mod = 1000000007;
int main() {
int n, m;
while (scanf("%d %d", &n, &m) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d %d", a + i, b + i);
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
if (a[i] != b[i]) {
dp[a[i]][i][2]++;
dp[b[i]][i][1]++;
} else
dp[a[i]][i][1]++;
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
if (dp[i][j][1]) {
for (int k = 1; k <= n; k++) {
if (k != j) {
if (a[k] != b[k]) {
if (b[k] == a[j] && i + b[k] <= m) {
dp[i + b[k]][k][1] = (dp[i][j][1] + dp[i + b[k]][k][1]) % mod;
}
if (a[k] == a[j] && i + a[k] <= m) {
dp[i + a[k]][k][2] = (dp[i][j][1] + dp[i + a[k]][k][2]) % mod;
}
} else {
if (a[k] == a[j] && i + a[k] <= m) {
dp[i + a[k]][k][2] = (dp[i][j][1] + dp[i + a[k]][k][2]) % mod;
}
}
}
}
}
if (dp[i][j][2]) {
for (int k = 1; k <= n; k++) {
if (k != j) {
if (a[k] != b[k]) {
if (a[k] == b[j] && i + a[k] <= m) {
dp[i + a[k]][k][2] = (dp[i + a[k]][k][2] + dp[i][j][2]) % mod;
}
if (b[k] == b[j] && i + b[k] <= m) {
dp[i + b[k]][k][1] = (dp[i + b[k]][k][1] + dp[i][j][2]) % mod;
}
} else {
if (b[k] == b[j] && i + b[k] <= m) {
dp[i + b[k]][k][1] = (dp[i + b[k]][k][1] + dp[i][j][2]) % mod;
}
}
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + dp[m][i][1]) % mod;
ans = (ans + dp[m][i][2]) % mod;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
const int MAXL = 3010;
const int MOD = 1000000007;
int N, L;
int dp[MAXL][2 * MAXN];
int len[2 * MAXN], wid[2 * MAXN];
int main() {
for (int i = 0; i < 2 * MAXN; i++)
for (int j = 0; j < MAXL; j++) dp[i][j] = 0;
cin >> N >> L;
for (int i = 0; i < N; i++) {
cin >> len[2 * i] >> wid[2 * i];
len[2 * i + 1] = wid[2 * i];
wid[2 * i + 1] = len[2 * i];
}
for (int i = 0; i < 2 * N; i++) dp[len[i]][i] = 1;
for (int i = 0; i <= L; i++) {
for (int j = 0; j < 2 * N; j++) {
for (int k = 0; k < 2 * N; k++) {
if (j / 2 == k / 2) continue;
if ((j % 2 == 1) && len[j] == wid[j]) continue;
if ((k % 2 == 1) && len[k] == wid[k]) continue;
if (len[k] != wid[j]) continue;
if (i < len[k]) continue;
dp[i][k] = (dp[i][k] + dp[i - len[k]][j]) % MOD;
}
}
}
int ans = 0;
for (int i = 0; i < 2 * N; i++)
if (i % 2 == 0 || len[i] != wid[i]) ans = (ans + dp[L][i]) % MOD;
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long int vis[201][3001], dp[201][3001], n, l;
vector<long long int> v[100001];
pair<long long int, long long int> a[100001];
long long int func(long long int last, long long int left) {
if (left < 0) return 0;
if (left == 0) return 1;
if (vis[last][left]) return dp[last][left];
vis[last][left] = 1;
long long int ret = 0;
for (long long int i = 0; i < v[last].size(); i++) {
int cur = v[last][i];
if (cur % n == last) continue;
ret += func(cur, left - (cur >= n ? a[cur - n].second : a[cur].first));
if (ret >= 1000000007) ret -= 1000000007;
}
dp[last][left] = ret;
return ret;
}
int main() {
long long int i, j, ans = 0;
cin >> n >> l;
for (i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) continue;
if (a[j].first == a[i].second) v[i].push_back(j);
if (a[j].first != a[j].second && a[i].second == a[j].second)
v[i].push_back(j + n);
if (a[i].first == a[i].second) continue;
if (a[i].first == a[j].first) v[i + n].push_back(j);
if (a[j].first != a[j].second && a[i].first == a[j].second)
v[i + n].push_back(j + n);
}
}
for (i = 0; i < n; i++) {
ans += func(i, l - a[i].first);
if (ans >= 1000000007) ans -= 1000000007;
if (a[i].first != a[i].second) {
ans += func(i + n, l - a[i].second);
if (ans >= 1000000007) ans -= 1000000007;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, l;
int dp[3005][105][2];
int a[105][2];
int main() {
while (cin >> n >> l) {
for (int i = 0; i < n; i++) scanf("%d%d", &a[i][0], &a[i][1]);
memset(dp, 0, sizeof(dp));
for (int k = 1; k <= l; k++)
for (int i = 0; i < n; i++)
for (int p = 0; p < 2 - (a[i][0] == a[i][1]); p++) {
if (k - a[i][p] == 0) {
dp[k][i][p] = 1;
continue;
}
for (int j = 0; j < n; j++)
if (i != j)
for (int q = 0; q < 2 - (a[j][0] == a[j][1]); q++)
if (a[i][p] == a[j][q] && k >= a[i][p])
dp[k][i][p] =
(dp[k][i][p] +
dp[k - a[i][p]][j][q ^ (1 & (a[j][0] != a[j][1]))]) %
mod;
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int p = 0; p < 2; p++) ans = (ans + dp[l][i][p]) % mod;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l, n;
long long ans = 0;
int a[2][120];
long long dp[2][3300][120];
long long MOD = 1e9 + 7;
void init() {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3300; j++) {
for (int k = 0; k < 120; k++) {
dp[i][j][k] = -1;
}
}
}
}
long long dyn(int t, int l, int j) {
if (l < 0) return 0;
if (dp[t][l][j] != -1) return dp[t][l][j];
if (l == 0) return 1;
dp[t][l][j] = 0;
for (int i = 0; i < n; i++) {
if (i == j) continue;
if (a[t][j] == a[0][i]) {
dp[t][l][j] += dyn(1, l - a[1][i], i);
} else {
if (a[t][j] == a[1][i]) {
dp[t][l][j] += dyn(0, l - a[0][i], i);
}
}
dp[t][l][j] %= MOD;
}
return dp[t][l][j];
}
int main() {
cin >> n >> l;
init();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
scanf("%d", &a[j][i]);
}
}
for (int i = 0; i < n; i++) {
if (a[0][i] == a[1][i]) {
ans += dyn(0, l - a[0][i], i);
} else {
ans += dyn(1, l - a[1][i], i);
ans += dyn(0, l - a[0][i], i);
}
}
cout << ans % MOD;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sq(T x) {
return x * x;
}
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
const long long maxint = 2147483647;
const long long minint = -2147483648;
struct fence {
int x, y;
} arr[110];
long long mod = 1000000007;
int n;
long long memo[101][2][3001];
int done[101][2][3001];
long long dp(int type, int dir, int len) {
if (len < 0) return 0;
if (len == 0) return 1;
if (done[type][dir][len]) return memo[type][dir][len];
long long res = 0;
int i;
int tx, ty;
tx = arr[type].x;
ty = arr[type].y;
if (dir) swap(tx, ty);
for (i = 0; i < n; i++) {
if (i == type) continue;
if (arr[i].x == ty) {
res = (res + dp(i, 0, len - arr[i].x)) % mod;
}
if (arr[i].x != arr[i].y && arr[i].y == ty) {
res = (res + dp(i, 1, len - arr[i].y)) % mod;
}
}
done[type][dir][len] = 1;
return memo[type][dir][len] = res;
}
int main() {
int l;
scanf("%d %d", &n, &l);
int i;
for (i = 0; i < n; i++) {
scanf("%d %d", &arr[i].x, &arr[i].y);
}
long long res = 0;
for (i = 0; i < n; i++) {
res = (res + dp(i, 0, l - arr[i].x)) % mod;
if (arr[i].x != arr[i].y) res = (res + dp(i, 1, l - arr[i].y)) % mod;
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int S = 101;
constexpr int L = 3005;
constexpr long long MOD = 1000000007;
long long DP[L][S][S] = {0};
int A[S] = {0};
int B[S] = {0};
int n, l;
long long solve(const int l, const int w, const int t) {
if (l == 0) return 1;
if (l < 0) return 0;
if (DP[l][w][t] != -1) return DP[l][w][t];
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i != t) {
if (A[i] == w) {
ans += solve(l - B[i], B[i], i) % MOD;
ans %= MOD;
}
if (A[i] != B[i] && B[i] == w) {
ans += solve(l - A[i], A[i], i) % MOD;
ans %= MOD;
}
}
}
DP[l][w][t] = ans;
return ans;
}
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> A[i] >> B[i];
}
for (int i = 0; i < L; i++)
for (int j = 0; j < S; j++)
for (int k = 0; k < S; k++) DP[i][j][k] = -1;
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += solve(l - A[i], A[i], i);
ans %= MOD;
if (A[i] != B[i]) {
ans += solve(l - B[i], B[i], i) % MOD;
ans %= MOD;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[107][3007][5];
int n, l;
int a[107], b[107];
int main() {
while (scanf("%d%d", &n, &l) != EOF) {
for (int i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
memset(dp, 0, sizeof dp);
for (int i = 0; i < n; i++) {
dp[i][a[i]][0] = 1;
if (a[i] != b[i]) dp[i][b[i]][1] = 1;
}
for (int j = 0; j <= l; j++)
for (int i = 0; i < n; i++) {
for (int k = 0; k < n; k++) {
if (i == k) continue;
if (a[i] != b[i]) {
if (b[i] == a[k] && j - a[i] >= 0)
dp[i][j][0] += dp[k][j - a[i]][0];
dp[i][j][0] %= 1000000007;
if (b[i] == b[k] && j - a[i] >= 0)
dp[i][j][0] += dp[k][j - a[i]][1];
dp[i][j][0] %= 1000000007;
if (a[i] == a[k] && j - b[i] >= 0)
dp[i][j][1] += dp[k][j - b[i]][0];
dp[i][j][1] %= 1000000007;
if (a[i] == b[k] && j - b[i] >= 0)
dp[i][j][1] += dp[k][j - b[i]][1];
dp[i][j][1] %= 1000000007;
} else if (a[i] == b[i]) {
if (b[i] == a[k] && j - a[i] >= 0)
dp[i][j][0] += dp[k][j - a[i]][0];
dp[i][j][0] %= 1000000007;
if (b[i] == b[k] && j - a[i] >= 0)
dp[i][j][0] += dp[k][j - a[i]][1];
dp[i][j][0] %= 1000000007;
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += dp[i][l][0];
ans %= 1000000007;
ans += dp[i][l][1];
ans %= 1000000007;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007ll;
long long dp[107][3007][2];
int a[3007], b[3007];
int main() {
int n, l;
scanf("%d%d", &n, &l);
memset(dp, 0, sizeof dp);
for (int i = 0; i < n; i++) {
scanf("%d%d", a + i, b + i);
dp[i][a[i]][0] = 1;
if (a[i] != b[i]) dp[i][b[i]][1] = 1;
}
for (int j = 1; j <= l; j++) {
for (int i = 0; i < n; i++) {
if (a[i] < j) {
for (int k = 0; k < n; k++)
if (i != k) {
if (a[i] == b[k]) {
dp[i][j][0] += dp[k][j - a[i]][0];
dp[i][j][0] %= mod;
}
if (a[i] == a[k]) {
dp[i][j][0] += dp[k][j - a[i]][1];
dp[i][j][0] %= mod;
}
}
}
if (a[i] != b[i] && b[i] < j) {
for (int k = 0; k < n; k++)
if (i != k) {
if (b[i] == b[k]) {
dp[i][j][1] += dp[k][j - b[i]][0];
dp[i][j][1] %= mod;
}
if (b[i] == a[k]) {
dp[i][j][1] += dp[k][j - b[i]][1];
dp[i][j][1] %= mod;
}
}
}
}
}
long long res = 0;
for (int i = 0; i < n; i++) {
res += (dp[i][l][0] + dp[i][l][1]) % mod;
res %= mod;
}
printf(
"%lld"
"\n",
res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > M;
vector<int> widths;
vector<int> lengths;
vector<int> type;
int n;
int l;
vector<vector<int> > width;
vector<vector<int> > length;
int cnt;
int count() {
for (int i = 0; i < n + cnt; ++i) {
M[i][0] = 1;
}
for (int j = 1; j < l; ++j) {
for (int i = 0; i < n + cnt; ++i) {
int lastWidth = widths[i];
M[i][j] = 0;
for (int k = 0; lastWidth <= j and k < length[lastWidth].size(); ++k) {
if (type[i] != type[length[lastWidth][k]])
M[i][j] += M[length[lastWidth][k]][j - lastWidth];
M[i][j] %= 1000000007;
}
}
}
int res = 0;
for (int i = 0; i < n + cnt; ++i) {
if (l >= lengths[i]) {
res += M[i][l - lengths[i]];
res %= 1000000007;
}
}
return res;
}
int main() {
cin >> n >> l;
M = vector<vector<int> >(2 * n, vector<int>(l, -1));
lengths = vector<int>(2 * n, 0);
widths = vector<int>(2 * n, 0);
type = vector<int>(2 * n, 0);
length = vector<vector<int> >(101, vector<int>());
cnt = 0;
for (int i = 0; i < n; ++i) {
int len, wid;
cin >> len >> wid;
lengths[i] = len;
widths[i] = wid;
length[len].push_back(i);
type[i] = i;
if (len != wid) {
type[n + cnt] = i;
swap(len, wid);
lengths[n + cnt] = len;
widths[n + cnt] = wid;
length[len].push_back(n + cnt);
++cnt;
}
}
cout << count() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct wood {
long long wid, len;
};
long long MOD = 1000000007;
long long F[201][3001];
long long careful[201];
wood types[201];
long long tL = 0;
int main() {
long long n, l;
long long i, j, in, a, b;
long long ways;
long long totalways = 0;
cin >> n >> l;
for (i = 0; i <= 200; i++) careful[i] = 0;
for (i = 1; i <= n; i++) {
cin >> a >> b;
tL++;
types[tL].len = a;
types[tL].wid = b;
if (a != b) {
careful[tL] = tL + 1;
careful[tL + 1] = tL;
tL++;
types[tL].len = b;
types[tL].wid = a;
}
}
for (i = 0; i <= 200; i++) {
for (j = 0; j <= 3000; j++) F[i][j] = 0;
}
for (i = 1; i <= l; i++) {
for (j = 1; j <= tL; j++) {
ways = 0;
if (types[j].len > i) continue;
if (types[j].len == i) {
F[j][i] = 1;
continue;
}
for (in = 1; in <= tL; in++) {
if (in == j || careful[j] == in) continue;
if (types[in].wid == types[j].len) {
ways = (ways + F[in][i - types[j].len]) % MOD;
}
}
F[j][i] = ways;
}
}
for (i = 1; i <= tL; i++) {
totalways = (totalways + F[i][l]) % MOD;
}
cout << totalways << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 305;
const int Mod = 1000000007;
int dp[5000][maxn];
int a[maxn], b[maxn], t[maxn];
int n, l;
int main() {
int i, j, k;
scanf("%d%d", &n, &l);
k = n;
for (i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
t[i] = i;
if (a[i] != b[i]) {
a[++k] = b[i];
b[k] = a[i];
t[k] = i;
}
}
n = k;
for (i = 1; i <= n; i++) dp[a[i]][i] = 1;
for (i = 0; i <= l; i++) {
for (j = 1; j <= n; j++) {
if (!dp[i][j]) continue;
for (k = 1; k <= n; k++) {
if (t[j] == t[k]) continue;
if (a[k] == b[j]) dp[i + a[k]][k] = (dp[i + a[k]][k] + dp[i][j]) % Mod;
}
}
}
int ans = 0;
for (i = 1; i <= n; i++) ans = (ans + dp[l][i]) % Mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long int dp[104][3005][2], n;
long long int a[1045], b[1045];
long long int cal(long long int x, long long int y, long long int f) {
long long int i;
if (y < 0) return 0;
if (y == 0) return 1;
long long int &r = dp[x][y][f];
if (r != -1) return r;
r = 0;
long long int l = a[x], w = b[x];
if (f == 1) swap(l, w);
for (i = 1; i <= n; i++) {
if (i == x) continue;
if (a[i] == w) r += cal(i, y - a[i], 0);
r %= 1000000007;
if (a[i] == b[i]) continue;
if (b[i] == w) r += cal(i, y - b[i], 1);
r %= 1000000007;
}
return r;
}
int main() {
long long int m, i, j;
while (cin >> n >> m) {
for (i = 1; i <= n; i++) cin >> a[i] >> b[i];
memset(dp, -1, sizeof(dp));
long long int ans = 0;
for (i = 1; i <= n; i++) {
ans += cal(i, m - a[i], 0);
ans %= 1000000007;
if (a[i] == b[i]) continue;
ans += cal(i, m - b[i], 1);
ans %= 1000000007;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sigma(long long n) { return (n * (n + 1) / 2); }
long long MOD(long long x) {
if (x >= 0) return x;
return (-x);
}
bool great(long long a, long long b) { return a > b; }
long long max3(long long a, long long b, long long c) {
return (max(a, max(b, c)));
}
long long max4(long long a, long long b, long long c, long long d) {
return (max(max(a, b), max(c, d)));
}
long long min3(long long a, long long b, long long c) {
return (min(a, min(b, c)));
}
long double min4(long double a, long double b, long double c, long double d) {
return (min(min(a, b), min(c, d)));
}
vector<long long> factors(long long x) {
vector<long long> v;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
v.push_back(i);
if (i != x / i) {
v.push_back(x / i);
}
}
}
return v;
}
vector<long long> min_prime;
unordered_map<long long, long long> prime_fact(long long x) {
unordered_map<long long, long long> mp;
while (x != 1) {
mp[min_prime[x]]++;
x /= min_prime[x];
}
return mp;
}
map<long long, long long> factorizee(long long n) {
map<long long, long long> mp;
for (long long i = 2; i * i <= n; ++i) {
while (n % i == 0) {
mp[i]++;
n /= i;
}
}
if (n != 1) {
mp[n]++;
}
return mp;
}
long long power(long long a, long long b, long long m) {
long long ans = 1;
while (b > 0) {
if (b % 2) {
ans = (ans * a) % m;
}
a = (a * a) % m;
b = b / 2;
}
return ans;
}
long long dp[101][2][3005];
vector<pair<long long, long long> > a;
long long doer(long long in, long long z, long long l) {
if (l == 0) {
return 1;
}
if (l < 0) {
return 0;
}
if (dp[in][z][l] != -1) {
return dp[in][z][l];
}
long long h = a[in].first;
long long b = a[in].second;
if (z) {
swap(h, b);
}
dp[in][z][l] = 0;
for (long long i = 0; i < a.size(); i++) {
if (i == in) {
continue;
}
if (a[i].first == a[i].second) {
if (a[i].first == b) {
dp[in][z][l] += doer(i, 0, l - a[i].first);
dp[in][z][l] %= 1000000007;
}
continue;
}
if (a[i].first == b) {
dp[in][z][l] += doer(i, 0, l - a[i].first);
dp[in][z][l] %= 1000000007;
continue;
}
if (a[i].second == b) {
dp[in][z][l] += doer(i, 1, l - a[i].second);
dp[in][z][l] %= 1000000007;
}
}
return dp[in][z][l];
}
int main() {
memset(dp, -1, sizeof(dp));
long long n, l;
cin >> n >> l;
a.resize(n);
for (long long i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (a[i].first == a[i].second) {
ans += doer(i, 0, l - a[i].first);
ans %= 1000000007;
continue;
}
ans += doer(i, 0, l - a[i].first);
ans %= 1000000007;
ans += doer(i, 1, l - a[i].second);
ans %= 1000000007;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
template <class T>
inline string ns(const T &number) {
stringstream ss;
ss << number;
return ss.str();
}
template <class T>
inline T sn(const string &text) {
stringstream ss(text);
T result;
return ss >> result ? result : 0;
}
int main() {
srand(time(NULL));
int n, l;
cin >> n >> l;
vector<pair<int, int> > board;
vector<int> type;
for (int i = 0; i < (n); ++i) {
int x, y;
cin >> x >> y;
if (x <= l) {
board.push_back(make_pair(x, y));
type.push_back(i);
}
if (x != y && y <= l) {
board.push_back(make_pair(y, x));
type.push_back(i);
}
}
n = (int)(board).size();
vector<vector<int> > dp(l + 1, vector<int>(n, 0));
for (int i = 0; i < (n); ++i) dp[board[i].first][i] = 1;
for (int i = (1); i <= (l); ++i)
for (int j = 0; j < (n); ++j)
for (int k = 0; k < (n); ++k)
if (type[j] != type[k] && board[j].first == board[k].second)
if (board[j].first + board[k].first <= i)
dp[i][j] = (dp[i][j] + dp[i - board[j].first][k]) % 1000000007;
int res = 0;
for (int i = 0; i < (n); ++i) res = (res + dp[l][i]) % 1000000007;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int nax = 101;
const int len = 3010;
int a[nax], b[nax];
const ll mod = 1e9 + 7;
ll dp[len][len][3];
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < n; i++) {
if (b[i] != a[i]) {
dp[a[i]][i][0]++;
dp[b[i]][i][1]++;
} else
dp[a[i]][i][2]++;
}
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (j == k) continue;
if (a[j] == b[j] && a[k] != b[k]) {
if (i >= a[j] && a[j] == b[k]) dp[i][j][2] += dp[i - a[j]][k][0];
dp[i][j][2] = dp[i][j][2] % mod;
if (i >= b[j] && b[j] == a[k]) dp[i][j][2] += dp[i - b[j]][k][1];
dp[i][j][2] = dp[i][j][2] % mod;
continue;
}
if (a[j] == b[j] && a[k] == b[k]) {
if (i >= a[j] && a[j] == a[k]) dp[i][j][2] += dp[i - a[j]][k][2];
dp[i][j][2] = dp[i][j][2] % mod;
continue;
}
if (a[k] == b[k]) {
if (i >= a[j] && a[j] == a[k]) dp[i][j][0] += dp[i - a[j]][k][2];
dp[i][j][0] = dp[i][j][0] % mod;
if (i >= b[j] && b[j] == a[k]) dp[i][j][1] += dp[i - b[j]][k][2];
dp[i][j][1] = dp[i][j][1] % mod;
continue;
}
if (i >= a[j] && a[j] == b[k]) dp[i][j][0] += dp[i - a[j]][k][0];
dp[i][j][0] = dp[i][j][0] % mod;
if (i >= a[j] && a[j] == a[k]) dp[i][j][0] += dp[i - a[j]][k][1];
dp[i][j][0] = dp[i][j][0] % mod;
if (i >= b[j] && b[j] == b[k]) dp[i][j][1] += dp[i - b[j]][k][0];
dp[i][j][1] = dp[i][j][1] % mod;
if (i >= b[j] && b[j] == a[k]) dp[i][j][1] += dp[i - b[j]][k][1];
dp[i][j][1] = dp[i][j][1] % mod;
}
}
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += dp[l][i][0];
ans %= mod;
ans += dp[l][i][1];
ans %= mod;
ans += dp[l][i][2];
ans %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000052], b[1000005];
int dp[4005][105][2];
const long long mod = 1e9 + 7;
int main() {
int n, m, y, x, i, j, k, t;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
}
for (i = 1; i <= n; i++) {
dp[a[i]][i][0]++;
if (b[i] != a[i]) {
dp[b[i]][i][1]++;
}
}
for (i = 1; i < m; i++) {
for (j = 1; j <= n; j++) {
for (k = 1; k <= n; k++) {
if (k != j) {
if (a[k] == b[j]) {
dp[i + a[k]][k][0] += dp[i][j][0];
dp[i + a[k]][k][0] %= mod;
}
if (a[k] != b[k] && b[k] == b[j]) {
dp[i + b[k]][k][1] += dp[i][j][0];
dp[i + b[k]][k][1] %= mod;
}
if (a[k] == a[j]) {
dp[i + a[k]][k][0] += dp[i][j][1];
dp[i + a[k]][k][0] %= mod;
}
if (a[k] != b[k] && b[k] == a[j]) {
dp[i + b[k]][k][1] += dp[i][j][1];
dp[i + b[k]][k][1] %= mod;
}
}
}
}
}
long long ans = 0;
for (i = 1; i <= n; i++) {
ans += dp[m][i][0] + dp[m][i][1];
}
memset(dp, 0, sizeof(dp));
printf("%I64d\n", ans % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, l;
struct type {
int a;
int b;
int a2, b2;
};
long long dp[3002][102][2];
int main() {
scanf("%d%d", &n, &l);
type c[102];
int p = 1000000007;
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
c[i].a = a;
c[i].b = b;
c[i].a2 = b;
c[i].b2 = a;
}
for (int i = 0; i < n; i++) {
dp[c[i].a][i][0]++;
if (c[i].a != c[i].a2) {
dp[c[i].a2][i][1]++;
}
}
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (j != k) {
if (c[k].a == c[j].b) {
if (c[k].a + i <= l) {
dp[c[k].a + i][k][0] += dp[i][j][0];
dp[c[k].a + i][k][0] %= p;
}
}
if (c[k].a == c[j].b2) {
if (c[k].a + i <= l) {
dp[c[k].a + i][k][0] += dp[i][j][1];
dp[c[k].a + i][k][0] %= p;
}
}
if (c[k].a2 != c[k].a) {
if (c[k].a2 == c[j].b) {
if (c[k].a2 + i <= l) {
dp[c[k].a2 + i][k][1] += dp[i][j][0];
dp[c[k].a2 + i][k][1] %= p;
}
}
if (c[k].a2 == c[j].b2) {
if (c[k].a2 + i <= l) {
dp[c[k].a2 + i][k][1] += dp[i][j][1];
dp[c[k].a2 + i][k][1] %= p;
}
}
}
}
}
}
}
long long res = 0;
for (int i = 0; i < n; i++) {
res += dp[l][i][0] % p;
res %= p;
res += dp[l][i][1] % p;
res %= p;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long z[3101][101][101];
long long a[201];
long long b[201];
vector<pair<int, int>> per[201];
int main() {
int n, l;
cin >> n >> l;
long long ma = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
per[a[i]].push_back(make_pair(b[i], i));
z[b[i]][a[i]][i] += 1LL;
if (a[i] != b[i]) {
per[b[i]].push_back(make_pair(a[i], i));
z[a[i]][b[i]][i] += 1LL;
}
ma = max(ma, a[i]);
ma = max(ma, b[i]);
}
for (int i = 1; i <= l; i++)
for (int j = 1; j <= ma; j++)
for (int num = 1; num <= n; num++)
if (z[i][j][num])
for (int q = 0; q < per[j].size(); q++)
if (per[j][q].second != num) {
z[i + j][per[j][q].first][per[j][q].second] += z[i][j][num];
z[i + j][per[j][q].first][per[j][q].second] %= 1000000007;
}
long long ans = 0LL;
for (int i = 1; i <= ma; i++)
for (int j = 1; j <= n; j++) {
ans += z[l][i][j];
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[111][2];
int dp[111 * 32][111][2];
int main() {
int N, L;
int i, j, k, l;
cin >> N >> L;
for (i = 0; i < N; i++) {
cin >> s[i][0] >> s[i][1];
dp[s[i][0]][i][0] = 1;
if (s[i][1] != s[i][0]) dp[s[i][1]][i][1] = 1;
}
for (l = 1; l <= L; l++) {
for (i = 0; i < N; i++)
for (j = 0; j < N; j++) {
if (i == j) continue;
for (k = 0; k < 2; k++) {
if (k && s[j][k] == s[j][k - 1]) continue;
if (l >= s[i][0] && s[j][k ^ 1] == s[i][0]) {
dp[l][i][0] = (dp[l][i][0] + dp[l - s[i][0]][j][k]) % 1000000007;
}
if (l >= s[i][1] && s[i][0] != s[i][1] && s[j][k ^ 1] == s[i][1]) {
dp[l][i][1] = (dp[l][i][1] + dp[l - s[i][1]][j][k]) % 1000000007;
}
}
}
}
int res = 0;
for (i = 0; i < N; i++)
for (j = 0; j < 2; j++) res = (res + dp[L][i][j]) % 1000000007;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int maxn = 105;
int N, L;
int a[maxn];
int b[maxn];
long long dp[3005][maxn][2];
int main() {
cin >> N >> L;
for (int i = 0; i < N; ++i) {
scanf("%d%d", &a[i], &b[i]);
}
for (int i = 0; i < N; ++i) {
dp[a[i]][i][0] = 1;
dp[b[i]][i][1] = 1;
}
for (int i = 1; i <= L; ++i) {
for (int j = 0; j < N; ++j) {
for (int k = 0; k < N; ++k) {
if (k == j) continue;
if (i >= a[j]) {
if (a[j] == b[k]) {
dp[i][j][0] += dp[i - a[j]][k][0];
} else if (a[j] == a[k]) {
dp[i][j][0] += dp[i - a[j]][k][1];
}
}
if (i >= b[j]) {
if (b[j] == b[k]) {
dp[i][j][1] += dp[i - b[j]][k][0];
} else if (b[j] == a[k]) {
dp[i][j][1] += dp[i - b[j]][k][1];
}
}
}
dp[i][j][0] %= MOD;
dp[i][j][1] %= MOD;
}
}
long long ans = 0;
for (int i = 0; i < N; ++i) {
ans += dp[L][i][0];
if (a[i] != b[i]) ans += dp[L][i][1];
}
ans %= MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tavan(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
struct cube {
long long w, h, id;
cube(long long a, long long b, long long c) : w(a), h(b), id(c) {}
};
long long n, l, dp[(111) * 2][3100];
vector<cube> c;
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
c.push_back(cube(a, b, i));
dp[c.size() - 1][a] = 1;
if (a != b) c.push_back(cube(b, a, i)), dp[c.size() - 1][b] = 1;
}
for (int j = 1; j <= l; j++)
for (int i = 0; i < c.size(); i++)
for (int p = 0; p < c.size(); p++) {
if (c[p].id == c[i].id) continue;
if (c[p].w == c[i].h)
dp[p][j + c[p].w] += dp[i][j],
dp[p][j + c[p].w] %= ((long long)1e9 + 7);
}
long long ans = 0;
for (int i = 0; i < c.size(); i++) {
ans += dp[i][l];
ans %= ((long long)1e9 + 7);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[3002][102][2];
int a[102], b[102];
int main() {
int n, l, i, j, k;
cin >> n >> l;
for (i = 0; i < n; i++) cin >> a[i] >> b[i];
memset(dp, 0, sizeof(dp));
for (i = 1; i <= l; i++)
for (j = 0; j < n; j++) {
if (a[j] == i) dp[i][j][0]++;
if (b[j] == i) dp[i][j][1]++;
}
for (i = 1; i <= l; i++)
for (j = 0; j < n; j++)
for (k = 0; k < n; k++) {
if (j == k) continue;
if (a[j] == a[k] && i > a[j] && dp[i - a[j]][k][1])
dp[i][j][0] = (dp[i][j][0] + dp[i - a[j]][k][1]) % 1000000007;
if (a[j] == b[k] && i > a[j] && a[k] != b[k] && dp[i - a[j]][k][0])
dp[i][j][0] = (dp[i][j][0] + dp[i - a[j]][k][0]) % 1000000007;
if (b[j] == b[k] && i > b[j] && dp[i - b[j]][k][0])
dp[i][j][1] = (dp[i][j][1] + dp[i - b[j]][k][0]) % 1000000007;
if (b[j] == a[k] && i > b[j] && a[k] != b[k] && dp[i - b[j]][k][1])
dp[i][j][1] = (dp[i][j][1] + dp[i - b[j]][k][1]) % 1000000007;
}
long long ans = 0;
for (i = 0; i < n; i++) {
ans = (ans + dp[l][i][0]) % 1000000007;
if (a[i] != b[i]) ans = (ans + dp[l][i][1]) % 1000000007;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int base = (int)1e9 + 7;
int f[30001][101][2];
int n, l, a[101][2], b[101][2];
void add(int &x, int y) { x = (x + y) % base; }
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> l;
for (int i = 1; i <= n; ++i) {
cin >> a[i][0] >> b[i][0];
a[i][1] = b[i][0];
b[i][1] = a[i][0];
}
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; ++i) {
add(f[a[i][0]][i][0], 1);
if (a[i][0] == a[i][1]) continue;
add(f[a[i][1]][i][1], 1);
}
for (int i = 0; i <= l; ++i)
for (int j = 1; j <= n; ++j)
for (int isTurn = 0; isTurn <= 1; ++isTurn) {
if (f[i][j][isTurn] == 0) continue;
for (int next = 1; next <= n; ++next) {
if (j == next) continue;
for (int turn = 0; turn <= 1; ++turn) {
if (turn == 1)
if (a[next][turn] == a[next][1 - turn]) break;
if (a[j][isTurn] != b[next][turn]) continue;
add(f[i + a[next][turn]][next][turn], f[i][j][isTurn]);
}
}
}
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int isTurn = 0; isTurn <= 1; ++isTurn) add(ans, f[l][i][isTurn]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[3001][100][2] = {0};
int main() {
const int mod = 1000000007;
int n, l;
scanf("%d%d", &n, &l);
int a[100], b[100];
for (int i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
for (int i = 0; i < n; i++) {
c[a[i]][i][0] = 1;
c[b[i]][i][1] = 1;
}
for (int i = 1; i <= l; i++)
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++)
if (k != j) {
if (a[j] == b[k] && i - a[j] >= 0)
c[i][j][0] = (c[i][j][0] + c[i - a[j]][k][0]) % mod;
if (b[k] != a[k] && a[j] == a[k] && i - a[j] >= 0)
c[i][j][0] = (c[i][j][0] + c[i - a[j]][k][1]) % mod;
if (b[j] == b[k] && i - b[j] >= 0)
c[i][j][1] = (c[i][j][1] + c[i - b[j]][k][0]) % mod;
if (b[k] != a[k] && b[j] == a[k] && i - b[j] >= 0)
c[i][j][1] = (c[i][j][1] + c[i - b[j]][k][1]) % mod;
}
}
int s = 0;
for (int i = 0; i < n; i++) {
s = (s + c[l][i][0]) % mod;
if (a[i] != b[i]) s = (s + c[l][i][1]) % mod;
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fence {
long long x, y, ind;
};
const int MAXN = 3000 + 100, MAXM = 200 + 10;
int dp[MAXN][MAXM];
long long MOD = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, l, t = 0;
cin >> n >> l;
fence f[2 * n];
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
f[t].x = a;
f[t].y = b;
f[t].ind = t;
if (a != b) {
t++;
f[t].x = b;
f[t].y = a;
f[t].ind = t - 1;
}
t++;
}
n = t;
for (int i = 0; i < n; i++) dp[f[i].y][i] = 1;
for (int j = 0; j <= l; j++) {
for (int i = 0; i < n; i++) {
if (f[i].y <= j) {
for (int d = 0; d < n; d++) {
if (f[d].ind != f[i].ind && f[d].y == f[i].x)
dp[j][i] = (dp[j][i] + dp[j - f[i].y][d]) % MOD;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) ans = (ans + dp[l][i]) % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long ans;
long long n, l;
long long x[105];
long long y[105];
long long dp[105][105][3005];
long long solve(long long ind, long long w, long long len) {
if (len > l) return 0LL;
if (len == l) return 1LL;
if (dp[ind][w][len] != -1) return dp[ind][w][len];
long long res = 0LL;
for (int i = 0; i < n; i++) {
if (i == ind) continue;
if (x[i] == w) res += solve(i, y[i], len + x[i]);
res %= MOD;
if (x[i] == y[i]) continue;
if (y[i] == w) res += solve(i, x[i], len + y[i]);
res %= MOD;
}
return dp[ind][w][len] = (res % MOD);
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
for (int i = 0; i < n; i++) {
ans += solve(i, x[i], y[i]);
ans %= MOD;
if (y[i] == x[i]) continue;
ans += solve(i, y[i], x[i]);
ans %= MOD;
}
ans %= MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
const int MOD = 1e9 + 7, N = 102, L = 3005, INF = INT_MAX;
pair<long long, long long> a[N];
long long dp[L][N][2];
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
if (a[j].first == i)
dp[i][j][0] = 1;
else if (a[j].first < i) {
for (int c = 0; c < n; c++) {
if (c == j) continue;
if (a[c].second == a[j].first)
dp[i][j][0] += dp[i - a[j].first][c][0];
if (a[c].first == a[j].first && a[c].first != a[c].second)
dp[i][j][0] += dp[i - a[j].first][c][1];
dp[i][j][0] %= MOD;
}
}
if (a[j].second == i)
dp[i][j][1] = 1;
else if (a[j].second < i) {
for (int c = 0; c < n; c++) {
if (c == j) continue;
if (a[c].second == a[j].second)
dp[i][j][1] += dp[i - a[j].second][c][0];
if (a[c].first == a[j].second && a[c].first != a[c].second)
dp[i][j][1] += dp[i - a[j].second][c][1];
dp[i][j][1] %= MOD;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += dp[l][i][0];
if (a[i].first != a[i].second) ans += dp[l][i][1];
ans %= MOD;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
long long dp[3001][100][2];
int main() {
int n, l, m = 1000000007, i, j, k, p;
long long sum = 0;
int a[100][2];
scanf("%d %d", &n, &l);
for (i = 0; i < n; i++) scanf("%d %d", &a[i][0], &a[i][1]);
for (i = 0; i <= l; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < 2; k++) {
dp[i][j][k] = -1;
}
}
}
for (i = 0; i < n; i++) {
if (a[i][0] <= l) dp[a[i][0]][i][0] = 1;
if (a[i][0] != a[i][1] && a[i][1] <= l) dp[a[i][1]][i][1] = 1;
}
for (i = 0; i < l; i++) {
for (j = 0; j < n; j++) {
for (k = 0; k < 2; k++) {
if (dp[i][j][k] == -1) continue;
for (p = 0; p < n; p++) {
if (p == j) continue;
if (a[p][0] == a[j][k] && i + a[p][1] <= l) {
if (dp[i + a[p][1]][p][1] == -1) dp[i + a[p][1]][p][1] = 0;
dp[i + a[p][1]][p][1] += dp[i][j][k];
dp[i + a[p][1]][p][1] %= m;
}
if (a[p][0] != a[p][1] && a[p][1] == a[j][k] && i + a[p][0] <= l) {
if (dp[i + a[p][0]][p][0] == -1) dp[i + a[p][0]][p][0] = 0;
dp[i + a[p][0]][p][0] += dp[i][j][k];
dp[i + a[p][0]][p][0] %= m;
}
}
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < 2; j++) {
if (dp[l][i][j] == -1) continue;
sum += dp[l][i][j];
sum %= m;
}
}
printf("%d\n", (int)sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long long INF64 = (long long)1e18;
const long double eps = 1e-9;
const long double pi = 3.14159265358979323846;
bool ineedoutputfile = false;
const int mod = (int)(INF + 7);
int dp[3][150][4000], a[2][150], n, l;
int solve(int tl, int ty, int nl) {
if (nl < 0) return 0;
if (nl == 0) return 1;
if (dp[tl][ty][nl] != -1)
return dp[tl][ty][nl];
else {
long long ans = 0;
if (tl != 2) {
for (int i = 0; i < int(n); ++i) {
if (i != ty) {
if (a[0][i] == a[tl][ty])
ans = (ans + solve(1, i, nl - a[0][i])) % mod;
if (a[0][i] != a[1][i] && a[1][i] == a[tl][ty])
ans = (ans + solve(0, i, nl - a[1][i])) % mod;
}
}
} else {
for (int i = 0; i < int(n); ++i) {
ans = (ans + solve(1, i, nl - a[0][i])) % mod;
if (a[0][i] != a[1][i]) ans = (ans + solve(0, i, nl - a[1][i])) % mod;
}
}
return dp[tl][ty][nl] = ans % mod;
}
}
int main() {
scanf("%d%d", &n, &l);
memset(dp, -1, sizeof(dp));
for (int i = 0; i < int(n); ++i) scanf("%d%d", &a[0][i], &a[1][i]);
int ans = solve(2, 0, l);
cout << (ans) % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
struct board {
int l, w, ind;
};
vector<board> a;
long long dp[3201][201];
int used[101][101], ll, n;
void init() {
memset(dp, 0, sizeof(dp));
int ind = 0;
cin >> n >> ll;
for (int i = 1; i <= n; i++) {
board x;
cin >> x.l >> x.w;
x.ind = i;
a.push_back(x);
if (x.l != x.w) {
swap(x.l, x.w);
a.push_back(x);
}
}
n = a.size();
for (int i = 0; i <= n - 1; i++) {
dp[a[i].l][i] = 1;
}
for (int currlen = 1; currlen <= ll - 1; currlen++)
for (int i = 0; i <= n - 1; i++)
if (dp[currlen][i])
for (int j = 0; j <= n - 1; j++)
if (a[i].ind != a[j].ind) {
if (a[i].w == a[j].l) {
dp[currlen + a[j].l][j] += dp[currlen][i];
if (dp[currlen + a[j].l][j] >= 1000000007)
dp[currlen + a[j].l][j] -= 1000000007;
}
}
long long sol = 0;
for (int i = 0; i <= n - 1; i++) sol += (long long)dp[ll][i];
if (sol >= 1000000007) sol %= 1000000007;
if (sol < 0) sol += 1000000007;
cout << sol << endl;
}
int main() {
init();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = (long long)(1e9 + 7);
vector<vector<long long> > fences;
vector<vector<vector<long long> > > dp;
int n;
bool posible(long long m, long long wea, int lado) {
if (fences[m][lado] == wea) return true;
return false;
}
long long solve(long long l, long long m, int anterior) {
if (l == 0) return 1;
if (l < 0) return 0;
if (dp[l][m][anterior] != -1) return dp[l][m][anterior];
long long valor = 0;
for (int i = 0; i < n; i++) {
if (i != anterior - 1) {
if (posible(i, m, 0)) {
valor += (solve(l - fences[i][0], fences[i][1], i + 1));
}
if (posible(i, m, 1) && fences[i][0] != fences[i][1]) {
valor += (solve(l - fences[i][1], fences[i][0], i + 1));
}
}
}
valor = valor % MOD;
return dp[l][m][anterior] = valor;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int l;
cin >> n >> l;
fences.resize(n, vector<long long>(2));
for (int i = 0; i < n; i++) {
cin >> fences[i][0] >> fences[i][1];
}
dp.resize(l + 1,
vector<vector<long long> >(101, vector<long long>(n + 1, -1)));
long long valor = 0;
for (long long i = 1LL; i <= 100LL; i++) {
valor += solve(l, i, 0);
}
cout << valor % MOD << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007;
int n, len;
int z;
int h[200], w[200];
bool ok[200];
vector<int> widthmap[110];
void addmd(int &a, int b) {
a += b;
if (a >= md) {
a -= md;
}
if (a < 0) {
a += md;
}
}
int gettot(int, int);
int getdp(int, int);
int dptot[3010][110];
int gettot(int len, int width) {
if (len < 0) return 0;
int &res = dptot[len][width];
if (res != -1) return res;
res = 0;
for (int i = 0; i < (widthmap[width].size()); i++) {
addmd(res, getdp(len, widthmap[width][i]));
}
return res;
}
int dp[3010][210];
int getdp(int len, int i) {
int plen = len - h[i];
if (plen < 0) return 0;
if (plen == 0) return 1;
int &res = dp[len][i];
if (res != -1) return res;
res = 0;
addmd(res, gettot(plen, h[i]));
int oth = (i / 2) * 2 + 1 - (i % 2);
if (w[i] == h[i]) {
addmd(res, -getdp(plen, i));
} else {
addmd(res, -getdp(plen, oth));
}
return res;
}
int main() {
memset(dptot, -1, sizeof(dptot));
memset(dp, -1, sizeof(dp));
cin >> n >> len;
for (int i = 0; i < (n); i++) {
cin >> h[z] >> w[z];
ok[z] = true;
z++;
h[z] = w[z - 1];
w[z] = h[z - 1];
ok[z] = (h[z] != w[z]);
z++;
}
for (int i = 0; i < (z); i++) {
if (ok[i]) {
widthmap[w[i]].push_back(i);
}
}
int res = 0;
for (int i = 0; i < (z); i++) {
if (ok[i]) {
addmd(res, getdp(len, i));
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 100 + 5;
const long long MOD = 1000000007;
long long dp[MAX_N][3000 + 10][MAX_N];
vector<pair<long long, long long> > adj[MAX_N];
long long REC(long long s, long long p, long long l) {
if (p == 0) return 1LL;
if (p < 0) return 0LL;
if (dp[s][p][l] != -1) return dp[s][p][l];
dp[s][p][l] = 0;
for (long long i = 0; i < adj[s].size(); i++) {
if (adj[s][i].second != l)
dp[s][p][l] += REC(adj[s][i].first, p - s, adj[s][i].second);
dp[s][p][l] %= MOD;
}
return dp[s][p][l];
}
int main(void) {
memset(dp, -1, sizeof dp);
long long n, l;
cin >> n >> l;
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; i++) {
pair<long long, long long> T;
cin >> T.first >> T.second;
v.push_back(T);
}
for (long long i = 0; i < v.size(); i++) {
adj[v[i].first].push_back(make_pair(v[i].second, i));
if (v[i].second != v[i].first)
adj[v[i].second].push_back(make_pair(v[i].first, i));
}
long long ans = 0;
for (long long i = 0; i < v.size(); i++) {
ans += REC(v[i].second, l - v[i].first, i);
if (v[i].second != v[i].first) ans += REC(v[i].first, l - v[i].second, i);
ans %= MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct wood {
long long x, y, ind;
};
const int MAXN = 3000 + 100, MAXM = 200 + 10;
int dp[MAXN][MAXM];
long long mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, l, x, y, f = 0;
cin >> n >> l;
wood w[2 * n];
for (int i = 0; i < n; i++) {
cin >> x >> y;
w[f].x = x;
w[f].y = y;
w[f].ind = f;
if (w[f].x != w[f].y) {
w[f + 1].x = y;
w[f + 1].y = x;
w[f + 1].ind = f;
f++;
}
f++;
}
n = f;
for (int i = 0; i < n; i++) dp[w[i].y][i] = 1;
for (int i = 0; i <= l; i++)
for (int j = 0; j < n; j++)
if (i - w[j].y >= 0)
for (int k = 0; k < n; k++)
if (w[j].x == w[k].y and w[k].ind != w[j].ind)
dp[i][j] = (dp[i][j] + dp[i - w[j].y][k]) % mod;
long long ans = 0;
for (int i = 0; i < n; i++) ans = (ans + dp[l][i]) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int len[102][2], width[102][2], n;
long long memo[102][2][3002];
long long DP(int last, int id, int l) {
if (l < 0) return 0;
if (l == 0) return 1;
long long &ret = memo[last][id][l];
if (ret != -1) return ret;
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i == last) continue;
if (len[i][0] == width[last][id])
ans = (ans + DP(i, 0, l - len[i][0])) % 1000000007;
else if (len[i][1] == width[last][id])
ans = (ans + DP(i, 1, l - len[i][1])) % 1000000007;
}
return ret = ans;
}
int main() {
int l;
while (cin >> n >> l) {
for (int i = 0; i < n; i++) {
cin >> len[i][0] >> width[i][0];
len[i][1] = width[i][0];
width[i][1] = len[i][0];
}
memset(memo, -1, sizeof memo);
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
ans = (ans + DP(i, 0, l - len[i][0])) % 1000000007;
if (len[i][1] != width[i][1])
ans = (ans + DP(i, 1, l - len[i][1])) % 1000000007;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
int dmn[105][2];
int dp[105][2][3005];
int l, n;
int stg(int tp, int sd, int dn) {
if (dn > l) return 0;
if (dn == l) return 1;
if (dp[tp][sd][dn] != -1) return dp[tp][sd][dn];
int sm = 0;
int i;
for (i = 0; i < n; i++) {
if (i == tp) continue;
if (dmn[i][0] == dmn[tp][sd])
sm += stg(i, 1, dn + dmn[i][0]);
else if (dmn[i][1] == dmn[tp][sd])
sm += stg(i, 0, dn + dmn[i][1]);
sm %= 1000000007;
}
dp[tp][sd][dn] = sm;
return sm;
}
FILE* f1 = stdin;
int main() {
int i, j, k;
fscanf(f1, "%d%d", &n, &l);
for (i = 0; i < n; i++) fscanf(f1, "%d%d", &dmn[i][0], &dmn[i][1]);
for (i = 0; i < n; i++)
for (j = 0; j < 2; j++)
for (k = 0; k < l; k++) dp[i][j][k] = -1;
int sm = 0;
for (i = 0; i < n; i++)
for (j = 0; j < 2; j++) {
if (j == 1 && dmn[i][0] == dmn[i][1]) continue;
sm += stg(i, 1 - j, dmn[i][j]);
sm %= 1000000007;
}
printf("%d\n", sm);
scanf("%*d");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200, MAXE = 3010, MOD = 1000000007;
struct board {
int a, b, t;
};
board A[MAXN];
long long ans = 0, dp[MAXE][MAXN];
int n, l, k = 0;
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &A[k].a, &A[k].b);
A[k++].t = i;
if (A[k - 1].a != A[k - 1].b) {
A[k].a = A[k - 1].b;
A[k].b = A[k - 1].a;
A[k++].t = i;
}
}
memset(dp, 0, sizeof(dp));
for (int i = 0; i < k; ++i)
if (A[i].a <= l) dp[A[i].a][i] = 1;
for (int x = 1; x < l; ++x)
for (int y = 0; y < k; ++y)
for (int z = 0; z < k; ++z)
if (A[y].a + x <= l && A[z].t != A[y].t && A[z].b == A[y].a)
dp[A[y].a + x][y] = (dp[A[y].a + x][y] + dp[x][z]) % MOD;
ans = 0;
for (int i = 0; i < k; ++i) ans = (ans + dp[l][i]) % MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
int a[200][2];
int dp[112][3112][2];
const int mod = 1000000007;
int cdp(int i, int j, int k) {
if (dp[i][j][k] != -1) return dp[i][j][k];
if (j < a[i][k]) return dp[i][j][k] = 0;
if (j == a[i][k]) return dp[i][j][k] = 1;
dp[i][j][k] = 0;
for (int p = 0; p < n; ++p)
if (p != i) {
for (int q = 0; q < 2; ++q) {
if (q == 1 && a[p][0] == a[p][1]) break;
if (a[p][q ^ 1] == a[i][k])
dp[i][j][k] = (dp[i][j][k] + cdp(p, j - a[i][k], q)) % mod;
}
}
return dp[i][j][k] % mod;
}
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) scanf("%d%d", &a[i][0], &a[i][1]);
memset(dp, -1, sizeof(dp));
int summ = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 2; ++j) {
if (j == 1 && a[i][0] == a[i][1]) break;
summ = (summ + cdp(i, l, j)) % mod;
}
printf("%d\n", summ);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, L;
register int i, j, k, t;
int pd[3010][110][2];
int v[110][2];
scanf("%d %d", &N, &L);
for (i = 0; i < N; i++) {
scanf("%d %d", &v[i][0], &v[i][1]);
}
for (i = 0; i < N; i++) {
pd[0][i][0] = pd[0][i][1] = 1;
}
for (t = 1; t <= L; t++) {
for (i = 0; i < N; i++) {
for (k = 0; k < 2; k++) {
pd[t][i][k] = 0;
int tt = t - v[i][k];
if (tt == 0) {
pd[t][i][k] = 1;
continue;
}
if (tt < 0) continue;
for (j = 0; j < N; j++) {
if (i == j) continue;
if (v[j][0] == v[i][k]) {
pd[t][i][k] += pd[tt][j][1];
} else if (v[j][1] == v[i][k]) {
pd[t][i][k] += pd[tt][j][0];
}
pd[t][i][k] = (pd[t][i][k]) % 1000000007;
}
}
}
}
int s = 0;
if (N == 1) {
if (v[0][0] == L || v[0][1] == L) s++;
} else {
for (i = 0; i < N; i++) {
s += pd[L][i][0];
s %= 1000000007;
if (v[i][0] != v[i][1]) {
s += pd[L][i][1];
s %= 1000000007;
}
}
}
cout << s << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
while (1) {
a = a % b;
if (a == 0) return b;
b = b % a;
if (b == 0) return a;
}
}
const int inf = 1e9;
long long dp[3010][110][2];
int md = 1000000007, a[200], b[200];
int main() {
ios_base::sync_with_stdio(0);
int n, l, len;
memset(dp, 0, sizeof dp);
cin >> n >> len;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
for (l = 1; l <= len; l++) {
for (int i = 0; i < n; i++) {
if (l == a[i]) {
dp[l][i][0] = 1;
}
if (l == b[i] && a[i] != b[i]) {
dp[l][i][1] = 1;
}
if (l - a[i] > 0) {
for (int j = 0; j < n; j++) {
if (j != i) {
if (a[j] == a[i]) {
dp[l][i][0] += dp[l - a[i]][j][1];
}
if (b[j] == a[i]) {
dp[l][i][0] += dp[l - a[i]][j][0];
}
}
}
}
if (l - b[i] > 0 && a[i] != b[i]) {
for (int j = 0; j < n; j++) {
if (j != i) {
if (a[j] == b[i]) {
dp[l][i][1] += dp[l - b[i]][j][1];
}
if (b[j] == b[i]) {
dp[l][i][1] += dp[l - b[i]][j][0];
}
}
}
}
dp[l][i][0] %= md;
dp[l][i][1] %= md;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += dp[len][i][0];
ans += dp[len][i][1];
ans %= md;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int L, N, i, j, s, l;
int board[105][2];
unsigned int dp[3005][105][105], ou;
const unsigned int MOD = 1000000007;
int main() {
scanf("%d %d", &N, &L);
for (i = 1; i <= N; ++i) {
scanf("%d %d", &board[i][0], &board[i][1]);
dp[board[i][0]][board[i][1]][i]++;
if (board[i][0] != board[i][1]) dp[board[i][1]][board[i][0]][i]++;
}
for (l = 1; l <= L; ++l) {
for (i = 1; i <= N; ++i) {
for (s = 0; s < 2; ++s) {
if (board[i][0] == board[i][1]) s = 1;
if (board[i][s] <= l) {
for (j = 1; j <= N; ++j) {
if (i != j) {
dp[l][board[i][s ^ 1]][i] =
(dp[l][board[i][s ^ 1]][i] +
dp[l - board[i][s]][board[i][s]][j]) %
MOD;
}
}
}
}
}
}
for (i = 1; i <= 100; ++i)
for (j = 1; j <= N; ++j) {
ou = (ou + dp[L][i][j]) % MOD;
}
cout << ou << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int a[105][2];
int f[3005][105][2];
int main() {
int n, len;
scanf("%d %d", &n, &len);
for (int i = 0; i < n; ++i) {
scanf("%d %d", a[i] + 0, a[i] + 1);
}
memset(f, 0, sizeof f);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 1 + int(a[i][0] != a[i][1]); ++j) {
f[a[i][j]][i][j] += 1;
}
}
for (int i = 1; i <= len; ++i) {
for (int last = 0; last < n; ++last) {
for (int pos = 0; pos < 2; ++pos) {
int w = a[last][pos];
int h = a[last][1 - pos];
for (int nlast = 0; nlast < n; ++nlast) {
if (nlast != last) {
for (int npos = 0; npos < 1 + int(a[nlast][0] != a[nlast][1]);
++npos) {
int nw = a[nlast][npos];
int nh = a[nlast][1 - npos];
if (nw == h) {
if (i + nw <= len) {
f[i + nw][nlast][npos] += f[i][last][pos];
if (f[i + nw][nlast][npos] >= mod) {
f[i + nw][nlast][npos] -= mod;
}
}
}
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2; ++j) {
ans += f[len][i][j];
if (ans >= mod) {
ans -= mod;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[3009][109][2], a[109][2], n;
int memoize(int len, int pre, int use) {
if (len == 0) return 1;
if (len < 0) return 0;
if (dp[len][pre][use] != -1) return dp[len][pre][use];
int ans = 0;
for (int i = int(0); i <= int(n - 1); i++) {
if (i == pre) continue;
if (pre == n) {
ans += memoize(len - a[i][0], i, 0);
ans %= 1000000007;
if (a[i][0] != a[i][1]) ans += memoize(len - a[i][1], i, 1);
ans %= 1000000007;
} else {
if (a[pre][use ^ 1] == a[i][0]) {
ans += memoize(len - a[i][0], i, 0);
ans %= 1000000007;
}
if (a[pre][use ^ 1] == a[i][1] && a[i][0] != a[i][1]) {
ans += memoize(len - a[i][1], i, 1);
ans %= 1000000007;
}
}
}
return dp[len][pre][use] = ans;
}
int main() {
int l;
scanf("%d", &n);
scanf("%d", &l);
memset(dp, -1, sizeof(dp));
for (int i = int(0); i <= int(n - 1); i++) {
scanf("%d", &a[i][0]);
scanf("%d", &a[i][1]);
}
int ans = memoize(l, n, 0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10;
const int M = 1e9 + 7;
int a[N], b[N], dp[N][3][30 * N], n, l;
inline void fill_dp(int i, int s, int j) {
if (dp[i][s][j] != -1) return;
if (s && a[i] == b[i]) {
dp[i][s][j] = 0;
return;
}
if (!s) {
if (a[i] == j) {
dp[i][s][j] = 1;
return;
} else if (j < a[i]) {
dp[i][s][j] = 0;
return;
}
} else {
if (b[i] == j) {
dp[i][s][j] = 1;
return;
} else if (j < b[i]) {
dp[i][s][j] = 0;
return;
}
}
dp[i][s][j] = 0;
for (int k = 0; k < n; k++) {
if (k == i) continue;
if (s == 0) {
if (a[i] == b[k]) {
if (dp[k][0][j - a[i]] == -1) fill_dp(k, 0, j - a[i]);
dp[i][s][j] += dp[k][0][j - a[i]];
}
if (a[i] == a[k]) {
if (dp[k][1][j - a[i]] == -1) fill_dp(k, 1, j - a[i]);
dp[i][s][j] += dp[k][1][j - a[i]];
}
dp[i][s][j] %= M;
}
if (s == 1) {
if (s == 1 && b[i] == a[k]) {
if (dp[k][1][j - b[i]] == -1) fill_dp(k, 1, j - b[i]);
dp[i][s][j] += dp[k][1][j - b[i]];
}
if (s == 1 && b[i] == b[k]) {
if (dp[k][0][j - b[i]] == -1) fill_dp(k, 0, j - b[i]);
dp[i][s][j] += dp[k][0][j - b[i]];
}
dp[i][s][j] %= M;
}
}
}
int main() {
scanf("%d%d", &n, &l);
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
int ans = 0;
for (int i = 0; i < n; i++) {
fill_dp(i, 0, l);
fill_dp(i, 1, l);
ans += dp[i][0][l];
ans %= M;
ans += dp[i][1][l];
ans %= M;
}
printf("%d", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.