text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int c[3001][100][2] = {0}, x[100], y[100], m = 0;
int main() {
int n, l, i, j, k;
cin >> n >> l;
for (i = 0; i < n; i++) {
cin >> x[i] >> y[i];
c[x[i]][i][0] = 1;
c[y[i]][i][1] = 1;
}
for (i = 1; i <= l; i++)
for (j = 0; j < n; j++)
for (k = 0; k < n; k++)
if (j != k) {
if (i >= x[j] && x[j] == y[k])
c[i][j][0] = (c[i][j][0] + c[i - x[j]][k][0]) % 1000000007;
if (i >= x[j] && x[j] == x[k] && x[k] != y[k])
c[i][j][0] = (c[i][j][0] + c[i - x[j]][k][1]) % 1000000007;
if (i >= y[j] && y[j] == y[k])
c[i][j][1] = (c[i][j][1] + c[i - y[j]][k][0]) % 1000000007;
if (i >= y[j] && y[j] == x[k] && x[k] != y[k])
c[i][j][1] = (c[i][j][1] + c[i - y[j]][k][1]) % 1000000007;
}
for (i = 0; i < n; i++) {
m = (m + c[l][i][0]) % 1000000007;
if (x[i] != y[i]) m = (m + c[l][i][1]) % 1000000007;
}
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <typename T>
inline bool remin(T& c, const T& n) {
if (n < c) {
c = n;
return 1;
}
return 0;
}
template <typename T>
inline bool remax(T& c, const T& n) {
if (c < n) {
c = n;
return 1;
}
return 0;
}
template <typename T>
inline void addmod(T& c, const T& n, const T& m) {
c = (c + n) % m;
}
int _in;
int in() {
scanf("%d", &_in);
return _in;
}
const int N = 200, mod = 1e9 + 7;
bool comp[N][N];
vector<pair<int, int> > plate;
long long dp[3001][N];
int main() {
int n = in(), leng, i, j, k, p;
leng = in();
plate.resize(n);
for ((i) = (0); (i) < (n); ++(i))
scanf("%d%d", &plate[i].first, &plate[i].second);
memset(comp, 1, sizeof(comp));
for ((i) = (0); (i) < (n); ++(i))
if (plate[i].first != plate[i].second) {
comp[i][plate.size()] = comp[plate.size()][i] = false;
plate.push_back(pair<int, int>(plate[i].second, plate[i].first));
}
for ((i) = (0); (i) < ((plate).size()); ++(i))
for ((j) = (0); (j) < ((plate).size()); ++(j))
comp[j][i] &= i != j && plate[j].second == plate[i].first;
memset(dp, 0, sizeof(dp));
for ((i) = (0); (i) < (leng + 1); ++(i)) {
for ((j) = (0); (j) < ((plate).size()); ++(j)) {
p = i - plate[j].first;
if (p < 0) continue;
if (p == 0) {
dp[i][j] = 1;
} else {
for ((k) = (0); (k) < ((plate).size()); ++(k)) {
if (comp[k][j]) {
addmod(dp[i][j], dp[p][k], (long long)mod);
}
}
}
}
}
printf("%d\n", accumulate(dp[leng], dp[leng] + plate.size(), 0ll) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int dp[3001][101][101];
int a[101], b[101];
void solve() {
int n, l;
scanf("%d%d", &n, &l);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
dp[a[i]][i][b[i]] = 1;
if (a[i] != b[i]) {
dp[b[i]][i][a[i]] = 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 >= b[j]) {
dp[i][j][a[j]] =
(dp[i][j][a[j]] + dp[i - b[j]][k][b[j]]) % 1000000007;
}
if (i >= a[j] && a[j] != b[j]) {
dp[i][j][b[j]] =
(dp[i][j][b[j]] + dp[i - a[j]][k][a[j]]) % 1000000007;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + dp[l][i][a[i]]) % 1000000007;
if (a[i] != b[i]) {
ans = (ans + dp[l][i][b[i]]) % 1000000007;
}
}
printf("%lld\n", ans);
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
pair<int, int> p[102];
int dp[3003][102][2];
int gao() {
memset(dp, 0, sizeof(dp));
for (int j = 0; j < n; j++) {
dp[p[j].first][j][0] = 1;
if (p[j].first != p[j].second) {
dp[p[j].second][j][1] = 1;
}
}
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
for (int d = 0; d < 2; d++) {
int width = (d == 0) ? p[j].second : p[j].first;
for (int k = 0; k < n; k++) {
int gg = p[k].first == p[k].second ? 1 : 2;
for (int g = 0; g < gg; g++) {
int length = (g == 0) ? p[k].first : p[k].second;
if (j == k || width != length) {
continue;
}
if (i + length < 3003) {
dp[i + length][k][g] += dp[i][j][d];
dp[i + length][k][g] %= 1000000007;
}
}
}
}
}
}
int ans = 0;
for (int j = 0; j < n; j++) {
ans += dp[l][j][0];
ans %= 1000000007;
ans += dp[l][j][1];
ans %= 1000000007;
}
return ans;
}
int main() {
while (scanf("%d %d", &n, &l) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d %d", &p[i].first, &p[i].second);
}
int ans = gao();
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long z = 1e9 + 7;
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
return gcd(b, a % b);
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a) % z;
b--;
} else {
a = (a * a) % z;
b = b >> 1;
}
}
return res;
}
long long dp[30001][101][2];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n, l;
cin >> n >> l;
vector<pair<long long, long long> > v;
long long a, b;
memset(dp, 0, sizeof(dp));
for (long long i = 0; i < n; i++) {
cin >> a >> b;
v.push_back(make_pair(a, b));
}
for (long long i = 1; i <= l; i++) {
for (long long j = 0; j < n; j++) {
if (i == v[j].first) dp[i][j][0] = 1;
if (i == v[j].second && v[j].first != v[j].second) dp[i][j][1] = 1;
for (long long k = 0; k < n; k++) {
if (j != k) {
if (v[j].first == v[k].second && i - v[j].first > 0)
dp[i][j][0] += dp[i - v[j].first][k][0];
if (v[j].first == v[k].first && i - v[j].first > 0)
dp[i][j][0] += dp[i - v[j].first][k][1];
if (v[j].second == v[k].second && i - v[j].second > 0 &&
v[j].first != v[j].second)
dp[i][j][1] += dp[i - v[j].second][k][0];
if (v[j].second == v[k].first && i - v[j].second > 0 &&
v[j].first != v[j].second)
dp[i][j][1] += dp[i - v[j].second][k][1];
}
dp[i][j][0] %= z;
dp[i][j][1] %= z;
}
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += dp[l][i][0];
ans += dp[l][i][1];
ans %= z;
}
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
int n, l;
long long memo[103][3003][2];
int a[103], b[103];
long long go(int ult, int tam, int d) {
if (tam == l) return 1LL;
if (memo[ult][tam][d] != -1) return memo[ult][tam][d];
long long res = 0;
for (int i = 0; i < n; i++) {
if (i != ult) {
if (tam + a[i] <= l) {
if (d == 1 && b[ult] == a[i]) res = (res + go(i, tam + a[i], 1)) % mod;
if (d == 0 && a[ult] == a[i]) res = (res + go(i, tam + a[i], 1)) % mod;
}
if (a[i] == b[i]) continue;
if (tam + b[i] <= l) {
if (d == 1 && b[ult] == b[i]) res = (res + go(i, tam + b[i], 0) % mod);
if (d == 0 && a[ult] == b[i]) res = (res + go(i, tam + b[i], 0) % mod);
}
}
}
res %= mod;
return memo[ult][tam][d] = res;
}
int main() {
scanf("%d %d", &n, &l);
memset(memo, -1, sizeof memo);
for (int i = 0; i < n; i++) scanf("%d %d", &a[i], &b[i]);
long long res = 0;
for (int i = 0; i < n; i++) {
if (a[i] <= l) {
res = (res + go(i, a[i], 1));
if (res >= mod) res -= mod;
}
if (a[i] == b[i]) continue;
if (b[i] <= l) {
res = (res + go(i, b[i], 0));
if (res >= mod) res -= mod;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int N, L;
int board[105][2];
int dp[3005][105][2];
int main() {
cin >> N >> L;
for (int i = 0; i < N; i++) cin >> board[i][0] >> board[i][1];
for (int i = 0; i < N; i++)
for (int j = 0; j < 2; j++) dp[board[i][j]][i][j] = 1;
for (int i = 1; i <= L; i++)
for (int j = 0; j < N; j++)
for (int k = 0; k < 2; k++)
if (i - board[j][k] >= 0)
for (int m = 0; m < N; m++)
if (j != m) {
if (board[m][k ^ 1] == board[j][k])
dp[i][j][k] = (dp[i][j][k] + dp[i - board[j][k]][m][k]) % MOD;
else if (board[m][k] == board[j][k])
dp[i][j][k] =
(dp[i][j][k] + dp[i - board[j][k]][m][k ^ 1]) % MOD;
}
int ans = 0;
for (int i = 0; i < N; i++) {
ans = (ans + dp[L][i][0]) % MOD;
if (board[i][0] != board[i][1]) ans = (ans + dp[L][i][1]) % MOD;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
int mas[100][2], n, l;
long long results[3010][100][2];
scanf("%d%d", &n, &l);
for (int i = 0; i <= 3000; i++) {
for (int j = 0; j < 100; j++) {
results[i][j][0] = 0;
results[i][j][1] = 0;
}
}
for (int i = 0; i < n; i++) {
scanf("%d%d", &mas[i][0], &mas[i][1]);
}
for (int i = 0; i < n; i++) {
results[mas[i][0]][i][1] = 1;
if (mas[i][0] != mas[i][1]) results[mas[i][1]][i][0] = 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) continue;
if (mas[j][0] == mas[k][0]) {
if (mas[k][0] < i) {
results[i][k][1] =
(results[i][k][1] + results[i - mas[k][0]][j][0]) % 1000000007;
}
} else if (mas[j][0] == mas[k][1]) {
if (mas[k][1] < i) {
results[i][k][0] =
(results[i][k][0] + results[i - mas[k][1]][j][0]) % 1000000007;
}
}
if (mas[j][1] == mas[k][0]) {
if (mas[k][0] < i) {
results[i][k][1] =
(results[i][k][1] + results[i - mas[k][0]][j][1]) % 1000000007;
}
} else if (mas[j][1] == mas[k][1]) {
if (mas[k][1] < i) {
results[i][k][0] =
(results[i][k][0] + results[i - mas[k][1]][j][1]) % 1000000007;
}
}
}
}
}
long long result = 0;
for (int i = 0; i < n; i++) {
result += results[l][i][0];
result += results[l][i][1];
result %= 1000000007;
}
std::cout << result;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int V = 200;
int n, m;
int a[V], b[V];
int f[3200][V][2];
int mod(int x) { return x > 1000000007 ? x - 1000000007 : x; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
f[a[i]][i][0] = 1;
if (a[i] != b[i]) f[b[i]][i][1] = 1;
}
for (int i = 1; i <= m; i++)
for (int j = 0; j < n; j++)
for (int p = 0; p < 2; p++)
if (f[i][j][p] > 0) {
int next = (p == 0) ? b[j] : a[j];
for (int k = 0; k < n; k++)
if (k != j) {
if (a[k] == next) {
f[i + next][k][0] = mod(f[i + next][k][0] + f[i][j][p]);
} else if (b[k] == next) {
f[i + next][k][1] = mod(f[i + next][k][1] + f[i][j][p]);
}
}
}
int ans = 0;
for (int j = 0; j < n; j++)
for (int p = 0; p < 2; p++) ans = mod(ans + f[m][j][p]);
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXL = 3001;
const int MAXN = 101;
const int MOD = 1000000007;
int dp[MAXL][MAXN][2];
int ar[MAXN], br[MAXN];
int n, l, ans;
void init() { ans = 0; }
void input() {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &ar[i], &br[i]);
}
}
void output() { printf("%d\n", ans); }
void solved() {
for (int i = 0; i < n; ++i) {
dp[ar[i]][i][0] = 1;
if (ar[i] != br[i]) dp[br[i]][i][1] = 1;
}
for (int cl = 1; cl <= l; ++cl) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (i == j) continue;
if (cl - ar[i] >= 0) {
if (ar[i] == br[j]) {
dp[cl][i][0] = (dp[cl][i][0] + dp[cl - ar[i]][j][0]) % MOD;
}
if (ar[i] == ar[j]) {
dp[cl][i][0] = (dp[cl][i][0] + dp[cl - ar[i]][j][1]) % MOD;
}
}
if (ar[i] == br[i]) continue;
if (cl - br[i] >= 0) {
if (br[i] == br[j]) {
dp[cl][i][1] = (dp[cl][i][1] + dp[cl - br[i]][j][0]) % MOD;
}
if (br[i] == ar[j]) {
dp[cl][i][1] = (dp[cl][i][1] + dp[cl - br[i]][j][1]) % MOD;
}
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int z = 0; z < 2; ++z) {
ans = (ans + dp[l][i][z]) % MOD;
}
}
}
int main() {
init();
input();
solved();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
int dp[3001][101][2];
int fen[100][2];
int top(int s, int z, bool r) {
if (s > l) return 0;
if (s == l) return 1;
if (dp[s][z][r] != -1) return dp[s][z][r];
int& res = dp[s][z][r];
res = 0;
int len = fen[z][0];
int wid = fen[z][1];
if (r) swap(len, wid);
for (int i = 0; i < n; ++i) {
if (i == z) continue;
int nowlen = fen[i][0];
int nowwid = fen[i][1];
if (nowlen == wid) {
res += top(s + nowlen, i, 0);
res %= 1000000007;
}
if (nowlen != nowwid) {
swap(nowlen, nowwid);
if (nowlen == wid) {
res += top(s + nowlen, i, 1);
res %= 1000000007;
}
}
}
return res;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &fen[i][0], &fen[i][1]);
}
int res = 0;
for (int i = 0; i < n; ++i) {
res += top(fen[i][0], i, 0);
res %= 1000000007;
if (fen[i][0] != fen[i][1]) res += top(fen[i][1], i, 1);
res %= 1000000007;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int mod = 1e9 + 7;
const int ROT = 100;
int n, l;
struct board {
int a;
int b;
} boards[N];
int dp[3005][2 * N];
int ans;
int main() {
int i, j, k;
int a, b;
cin >> n >> l;
for (i = 1; i <= n; i++) {
scanf("%d%d", &boards[i].a, &boards[i].b);
}
for (i = 1; i <= l; i++) {
for (j = 1; j <= n; j++) {
a = boards[j].a;
b = boards[j].b;
if (i - a >= 0) {
if (i - a == 0)
dp[i][j] = (dp[i][j] + 1) % mod;
else {
for (k = 1; k <= n; k++) {
if (k != j) {
if (boards[k].b == a) dp[i][j] = (dp[i][j] + dp[i - a][k]) % mod;
if (boards[k].a == a)
dp[i][j] = (dp[i][j] + dp[i - a][k + ROT]) % mod;
}
}
}
}
if (a != b) {
swap(a, b);
if (i - a >= 0) {
if (i - a == 0)
dp[i][j + ROT] = (dp[i][j + ROT] + 1) % mod;
else {
for (k = 1; k <= n; k++) {
if (k != j) {
if (boards[k].b == a)
dp[i][j + ROT] = (dp[i][j + ROT] + dp[i - a][k]) % mod;
if (boards[k].a == a)
dp[i][j + ROT] = (dp[i][j + ROT] + dp[i - a][k + ROT]) % mod;
}
}
}
}
}
}
}
for (i = 1; i <= n; i++) {
ans = (ans + dp[l][i]) % mod;
ans = (ans + dp[l][i + ROT]) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int main() {
long long dp[3001][100][2] = {0};
long long n, l;
cin >> n >> l;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
dp[a[i]][i][0] = 1;
dp[b[i]][i][1] = 1;
}
for (long long i = 1; i <= l; ++i) {
for (long long j = 0; j < n; ++j) {
for (long long k = 0; k < n; ++k) {
if (j != k) {
if (a[j] == b[k] && i - a[j] >= 0) {
dp[i][j][0] = (dp[i][j][0] + dp[i - a[j]][k][0]) % mod;
}
if (a[j] == a[k] && a[k] != b[k] && i - a[j] >= 0) {
dp[i][j][0] = (dp[i][j][0] + dp[i - a[j]][k][1]) % mod;
}
if (b[j] == b[k] && a[j] != b[j] && i - b[j] >= 0) {
dp[i][j][1] = (dp[i][j][1] + dp[i - b[j]][k][0]) % mod;
}
if (b[j] == a[k] && a[j] != b[j] && a[k] != b[k] && i - b[j] >= 0) {
dp[i][j][1] = (dp[i][j][1] + dp[i - b[j]][k][1]) % mod;
}
}
}
}
}
long long res = 0;
for (long long i = 0; i < n; ++i) {
res = (res + dp[l][i][0]) % mod;
if (a[i] != b[i]) res = (res + dp[l][i][1]) % mod;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
long long total = 0;
long long mod = 1000000007;
long long dp[103][3003][2];
struct plank {
int width, length;
} a[1000];
long long func(int plank, int len, int orientation) {
long long cunt = 0;
if (len > l) return 0;
if (plank == n) return 0;
if (len == l) return 1;
int i;
if (dp[plank][len][orientation] != -1) return dp[plank][len][orientation];
if (orientation == 0) {
for (i = 0; i < n; i++) {
if (i == plank) continue;
if (a[plank].width == a[i].length) cunt += func(i, len + a[i].length, 0);
if (a[i].length != a[i].width) {
if (a[plank].width == a[i].width) cunt += func(i, len + a[i].width, 1);
}
}
}
if (orientation == 1) {
for (i = 0; i < n; i++) {
if (i == plank) continue;
if (a[plank].length == a[i].length) cunt += func(i, len + a[i].length, 0);
if (a[i].length != a[i].width) {
if (a[plank].length == a[i].width) cunt += func(i, len + a[i].width, 1);
}
}
}
return dp[plank][len][orientation] = cunt % mod;
}
int main() {
int i, j, fl, test;
scanf("%d %d", &n, &l);
for (i = 0; i < n; i++) {
scanf("%d %d", &a[i].length, &a[i].width);
}
memset(dp, -1, sizeof(dp));
for (i = 0; i < n; i++) {
total += func(i, a[i].length, 0);
total = total % mod;
if (a[i].length != a[i].width) total += func(i, a[i].width, 1);
total = total % mod;
}
printf("%lld\n", total % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200 + 10, maxNum = 100 + 10, maxL = 3000 + 10, P = 1000000007,
INF = 2147483647;
int N, L;
int f[maxL][maxN];
struct fence {
int A, B, Num;
} F[maxN];
void setIO(string name) {
string in = name + ".in";
string out = name + ".out";
freopen(in.c_str(), "r", stdin);
freopen(out.c_str(), "w", stdout);
}
int main() {
scanf("%d %d", &N, &L);
memset(f, 0, sizeof(f));
int a, b;
int cnt = -1;
for (int i = 0; i < N; ++i) {
scanf("%d %d", &a, &b), ++cnt;
F[cnt].A = a;
F[cnt].B = b;
F[cnt].Num = i;
if (a != b) {
++cnt;
F[cnt].A = b;
F[cnt].B = a;
F[cnt].Num = i;
}
}
N = cnt + 1;
for (int i = 0; i < N; ++i) f[F[i].A][i] = 1;
for (int i = 1; i <= L; ++i)
for (int j = 0; j < N; ++j)
for (int k = 0; k < N; ++k)
if (F[j].Num != F[k].Num && F[k].A < i && F[j].B == F[k].A)
f[i][k] = (f[i][k] + f[i - F[k].A][j]) % P;
int ans = 0;
for (int i = 0; i < N; ++i) ans = (ans + f[L][i]) % P;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dc[] = {0, 1, 0, -1, 1, -1, -1, 1};
const double eps = 1e-9;
const int INF = 0x7FFFFFFF;
const long long INFLL = 0x7FFFFFFFFFFFFFFFLL;
const double pi = acos(-1);
struct point_i {
int x, y;
point_i(int _x = 0, int _y = 0) {
x = _x;
y = _y;
}
};
struct point {
double x, y;
point(double _x = 0, double _y = 0) {
x = _x;
y = _y;
}
bool operator<(const point &other) const {
if (fabs(x - other.x) < eps) return y < other.y;
return x < other.x;
}
};
struct line_s {
point beg, end;
line_s() {
beg = point(0, 0);
end = point(0, 0);
}
line_s(point a, point b) : beg(a), end(b) {}
bool intersect(const line_s &other, point &ans) {
double mua, mub;
double denom, numera, numerb;
denom = (other.end.y - other.beg.y) * (end.x - beg.x) -
(other.end.x - other.beg.x) * (end.y - beg.y);
numera = (other.end.x - other.beg.x) * (beg.y - other.beg.y) -
(other.end.y - other.beg.y) * (beg.x - other.beg.x);
numerb = (end.x - beg.x) * (beg.y - other.beg.y) -
(end.y - beg.y) * (beg.x - other.beg.x);
if (denom == 0 && numera == 0 && numerb == 0) return 0;
mua = numera / denom;
mub = numerb / denom;
if (mua < 0 || mua > 1 || mub < 0 || mub > 1) {
ans.x = 0;
ans.y = 0;
return 0;
}
ans.x = beg.x + mua * (end.x - beg.x);
ans.y = beg.y + mua * (end.y - beg.y);
return 1;
}
};
struct line {
double a, b, c, len;
line() { a = b = c = 0.0; }
line(const point &a_, const point &b_) {
if (fabs(a_.x - b_.x) < eps) {
a = 1.0;
b = 0.0;
c = -a_.x;
} else {
a = -(double)(a_.y - b_.y) / (a_.x - b_.x);
b = 1.0;
c = -(double)(a_.x * a) - (double)(a_.y * b);
}
if (fabs(a) < eps) a = fabs(a);
if (fabs(b) < eps) b = fabs(b);
if (fabs(c) < eps) c = fabs(c);
double x = a_.x - b_.x, y = a_.y - b_.y;
len = sqrt((x * x) + (y * y));
}
bool parallel(const line &other) {
return (fabs(a - other.a) < eps && fabs(b - other.b) < eps);
}
bool same(const line &other) {
return (*this).parallel(other) && fabs(c - other.c) < eps;
}
};
int dp[3002][102][102];
int n, LEN, a, b;
const int MOD = 1000000007;
vector<pair<int, int> > vc[2];
int main() {
scanf("%d%d", &n, &LEN);
vc[0].push_back(make_pair(-1, -1));
vc[1].push_back(make_pair(-1, -1));
for (int(i) = (0), _t = (n); i < (_t); ++(i)) {
scanf("%d%d", &a, &b);
vc[0].push_back(make_pair(a, b));
vc[1].push_back(make_pair(b, a));
}
for (int(j) = (0), _t = (100); j <= (_t); ++(j)) dp[0][0][j] = 1;
for (int(i) = (1), _t = (LEN); i <= (_t); ++(i))
for (int(j) = (1), _t = (n); j <= (_t); ++(j)) {
if (i - (((vc[0][j].first) < (vc[0][j].second)) ? (vc[0][j].first)
: (vc[0][j].second)) <
0)
continue;
for (int(k) = (0), _t = (n); k <= (_t); ++(k)) {
if (j == k) continue;
if (i - vc[0][j].first < 0 || (i - vc[0][j].first > 0 && k == 0))
;
else {
dp[i][j][vc[0][j].second] +=
dp[i - vc[0][j].first][k][vc[0][j].first];
dp[i][j][vc[0][j].second] %= MOD;
}
if (vc[0][j] != vc[1][j])
if (i - vc[1][j].first < 0 || (i - vc[1][j].first > 0 && k == 0))
;
else {
dp[i][j][vc[1][j].second] +=
dp[i - vc[1][j].first][k][vc[1][j].first];
dp[i][j][vc[1][j].second] %= MOD;
}
}
}
int ans = 0;
for (int(i) = (0), _t = (101); i < (_t); ++(i))
for (int(j) = (0), _t = (101); j < (_t); ++(j)) {
ans += dp[LEN][i][j];
ans %= MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
string toString(long long v) {
ostringstream sout;
sout << v;
return sout.str();
}
string toString(int v) {
ostringstream sout;
sout << v;
return sout.str();
}
template <class T>
inline T countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <class T>
void out(T A[], int n) {
for (int i = 0; i < n; ++i) cout << A[i] << " ";
cout << endl;
}
template <class T>
void out(vector<T> A, int n = -1) {
if (n == -1) n = A.size();
for (int i = 0; i < n; ++i) cout << A[i] << " ";
cout << endl;
}
const int INF = 1000000000;
const long long MOD = 1000000007;
const int maxl = 3e3 + 200;
const int maxw = 110;
const int maxn = 110;
int dp[maxl][maxw][maxn];
int main() {
int n, L;
while (cin >> n >> L) {
vector<pair<int, int> > b(n + 1);
for (int i = (0); i < ((n)); ++i) cin >> b[i + 1].first >> b[i + 1].second;
memset((dp), 0, sizeof(dp));
for (int i = 1; i <= n; ++i) {
dp[b[i].first][b[i].second][i] += 1;
if (b[i].first != b[i].second) {
dp[b[i].second][b[i].first][i] += 1;
}
}
for (int i = 0; i < L; ++i) {
for (int w = 0; w < maxw; ++w) {
for (int t = 0; t <= n; ++t)
if (dp[i][w][t]) {
for (int k = 1; k <= n; ++k)
if (k != t && (b[k].first == w || b[k].second == w)) {
if (b[k].first == w) {
int& ref = dp[i + b[k].first][b[k].second][k];
long long tmp = (long long)ref + (long long)dp[i][w][t];
tmp %= MOD;
ref = tmp;
}
if (b[k].first != b[k].second && b[k].second == w) {
int& ref = dp[i + b[k].second][b[k].first][k];
long long tmp = (long long)ref + (long long)dp[i][w][t];
tmp %= MOD;
ref = tmp;
}
}
}
}
}
long long ans = 0;
for (int w = 0; w < maxw; ++w)
for (int t = 0; t < maxn; ++t) {
ans += dp[L][w][t];
ans %= MOD;
}
ans %= MOD;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
pair<int, int> ar[101];
long long dp[3001][101][2];
long long solve(int y, int s, int l) {
if (l > m) return 0;
if (l == m) return 1;
long long c1 = 0;
if (y != -1 && dp[l][y][s] != -1) return dp[l][y][s] % 1000000007;
for (int i = 1; i <= n; i++) {
if (y == -1) {
c1 += solve(i, 1, l + ar[i].first) % 1000000007;
if (ar[i].first != ar[i].second)
c1 += solve(i, 0, l + ar[i].second) % 1000000007;
} else {
if (i != y && ar[i].first == ar[y].second && s == 1)
c1 += solve(i, 1, l + ar[i].first) % 1000000007;
else if (i != y && ar[i].first == ar[y].first && s == 0)
c1 += solve(i, 1, l + ar[i].first) % 1000000007;
if (ar[i].first != ar[i].second) {
if (i != y && ar[i].second == ar[y].second && s == 1)
c1 += solve(i, 0, l + ar[i].second) % 1000000007;
else if (i != y && ar[i].second == ar[y].first && s == 0)
c1 += solve(i, 0, l + ar[i].second) % 1000000007;
}
}
}
return dp[l][y][s] = c1 % 1000000007;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
ar[i].first = x;
ar[i].second = y;
}
cout << solve(-1, 0, 0) % 1000000007;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x;
int v[110][2];
int memo[3500][110][2];
int MOD;
int calcula(int tam, int ind, int a) {
if (tam == x) return 1;
if (tam > x) return 0;
int res = 0;
if (memo[tam][ind][a] != -1) return memo[tam][ind][a];
int y = v[ind][a];
for (int i = 0; i < n; i++) {
if (i == ind) continue;
if (v[i][0] == y) {
res = (res + calcula(tam + y, i, 1)) % MOD;
}
if (v[i][1] != v[i][0] && v[i][1] == y) {
res = (res + calcula(tam + y, i, 0)) % MOD;
}
}
return memo[tam][ind][a] = res;
}
int main() {
MOD = 1000000007;
scanf("%d %d", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%d %d", &v[i][0], &v[i][1]);
}
memset(memo, -1, sizeof(memo));
int res = 0;
for (int i = 0; i < n; i++) {
res = (res + calcula(v[i][0], i, 1)) % MOD;
if (v[i][0] != v[i][1]) {
res = (res + calcula(v[i][1], i, 0)) % MOD;
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fence {
int width, height;
};
long long dp[3001][101][2];
int main() {
int n, l;
cin >> n >> l;
vector<fence> fences(n);
for (auto& el : fences) cin >> el.width >> el.height;
for (auto i = 0; i < n; i++) {
const auto& fence = fences[i];
dp[fence.width][i][0]++;
if (fence.height != fence.width) dp[fence.height][i][1]++;
}
for (auto i = 1; i <= l; i++) {
for (auto j = 0; j < n; j++) {
for (auto k = 0; k < n; k++) {
if (j == k) continue;
if (fences[j].width == fences[k].height && i - fences[j].width > 0)
dp[i][j][0] += dp[i - fences[j].width][k][0];
if (fences[j].height != fences[j].width &&
fences[j].height == fences[k].height && i - fences[j].height > 0)
dp[i][j][1] += dp[i - fences[j].height][k][0];
if (fences[j].width == fences[k].width && i - fences[j].width > 0)
dp[i][j][0] += dp[i - fences[j].width][k][1];
if (fences[j].height != fences[j].width &&
fences[j].height == fences[k].width && i - fences[j].height > 0)
dp[i][j][1] += dp[i - fences[j].height][k][1];
dp[i][j][0] %= 1000000007;
dp[i][j][1] %= 1000000007;
}
}
}
auto ans = 0ll;
for (auto i = 0; i < n; i++) {
ans += dp[l][i][0] + dp[l][i][1];
ans %= 1000000007;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[111][2];
int dp[111][2][3004];
int main() {
int N, L;
cin >> N >> L;
for (int i = 1; i <= N; i++) {
cin >> a[i][0] >> a[i][1];
}
dp[0][0][0] = 1;
int ans = 0;
for (int l = 1; l <= L; l++) {
for (int i = 1; i <= N; i++) {
for (int t1 = 0; t1 < 2 - (a[i][0] == a[i][1]); t1++) {
for (int j = 0; j <= N; j++) {
if (i == j) continue;
for (int t2 = 0; t2 < 2; t2++) {
if (l < a[i][t1]) continue;
if (!j || a[i][t1] == a[j][t2 ^ 1]) {
dp[i][t1][l] += (dp[j][t2][l - a[i][t1]]);
dp[i][t1][l] %= 1000000007;
}
}
}
if (l == L) {
ans = (ans + dp[i][t1][l]) % 1000000007;
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100;
const int MAXL = 3000;
const int MOD = 1e9 + 7;
int DP[2 * MAXN + 1][MAXL + 1];
vector<pair<int, pair<int, int>>> types;
int N, L, a, b;
int dp(int n, int l) {
if (l < 0) return 0;
if (DP[n][l] != -1) return DP[n][l];
int ans = 0;
for (int i = 0; i < types.size(); i++) {
if (types[i].first != types[n].first &&
types[n].second.first == types[i].second.second)
ans = (ans + dp(i, l - types[i].second.second)) % MOD;
}
return DP[n][l] = ans;
}
int main() {
memset(DP, -1, sizeof(DP));
cin >> N >> L;
for (int i = 0; i < N; i++) {
cin >> a >> b;
types.emplace_back(i, make_pair(a, b));
if (a != b) types.emplace_back(i, make_pair(b, a));
}
for (int i = 0; i < 2 * N; i++) DP[i][0] = 1;
int ans = 0;
for (int i = 0; i < types.size(); i++) {
ans = (ans + dp(i, L - types[i].second.second)) % MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 102;
const int MAXL = 3002;
const int MOD = 1000000007;
struct Board {
int a, b, type;
bool operator<(const Board& v) const { return a < v.a; }
};
Board board[MAXN * 2];
int dp[MAXL][MAXN * 2];
int main() {
int n, l;
scanf("%d %d", &n, &l);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &board[i].a, &board[i].b);
board[i].type = i;
}
int sz = n;
for (int i = 1; i <= n; i++) {
if (board[i].a == board[i].b) continue;
sz++;
board[sz].a = board[i].b, board[sz].b = board[i].a;
board[sz].type = board[i].type;
}
n = sz;
sort(board + 1, board + 1 + n);
for (int i = 0; i < l; i++) {
if (i == 0) {
for (int k = 1; k <= n; k++)
if (board[k].a <= l) dp[board[k].a][k]++;
} else
for (int j = 1; j <= n; j++) {
if (dp[i][j] == 0) continue;
for (int k = 1; k <= n; k++) {
if (board[k].a < board[j].b || board[k].type == board[j].type)
continue;
if (board[k].a + i > l || board[k].a > board[j].b) break;
dp[i + board[k].a][k] += dp[i][j];
if (dp[i + board[k].a][k] >= MOD) dp[i + board[k].a][k] -= MOD;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += dp[l][i];
if (ans >= MOD) ans -= MOD;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<long long, long long>>> vt;
long long n, m;
long long a[110][2];
long long dp[3010][110][2];
long long func(long long here, long long ch, long long ch2) {
if (here > m) return 0;
if (here == m) return 1;
long long &ret = dp[here][ch][ch2];
if (ret != -1) return ret;
ret = 0;
if (here == 0) {
for (int i = 1; i <= n; i++) {
ret += func(a[i][0], i, 0);
ret %= 1000000007;
if (a[i][0] != a[i][1]) {
ret += func(a[i][1], i, 1);
ret %= 1000000007;
}
}
} else {
long long xx = a[ch][ch2 ^ 1];
for (int i = 0; i < vt[xx].size(); i++) {
int next = vt[xx][i].second;
int ncst = vt[xx][i].first;
if (next != ch) {
ret += func(here + xx, next, ncst);
ret %= 1000000007;
}
}
}
return ret;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%lld %lld", &n, &m);
vt.resize(101);
for (int i = 1; i <= n; i++) {
long long q, w;
scanf("%lld %lld", &q, &w);
a[i][0] = q;
a[i][1] = w;
if (a[i][0] != a[i][1]) vt[q].push_back({0, i});
vt[w].push_back({1, i});
}
printf("%lld\n", func(0, 0, 0));
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> fences[210];
int dp[210][3010];
long long mod = 1e9 + 7;
int main() {
int n, len;
cin >> n >> len;
for (int i = 0; i < n; i++) {
int l, w;
cin >> l >> w;
fences[2 * i].first = fences[2 * i + 1].second = l;
fences[2 * i].second = fences[2 * i + 1].first = w;
}
for (int j = 1; j <= len; j++) {
for (int i = 0; i < 2 * n; i++) {
if ((fences[i].first == fences[i].second) && i % 2 == 1) continue;
if (j == fences[i].first) {
dp[i][j] = 1;
continue;
}
if (j < fences[i].first) continue;
int res = 0;
for (int k = 0; k < 2 * n; k++) {
if (k / 2 != i / 2 && fences[k].second == fences[i].first) {
res += (dp[k][j - fences[i].first] % mod);
res = res % mod;
}
}
dp[i][j] = res;
}
}
int ans = 0;
for (int i = 0; i < 2 * n; i++) {
ans += dp[i][len];
ans %= mod;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long z = 1000000000;
const long long N = 1e5 + 1;
const long long INF = 1e18;
template <typename T, typename T1>
T amax(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
long long powe(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long t = powe(x, y / 2);
t = (t * t) % mod;
if (y % 2 == 1) t = (t * x) % mod;
return t;
}
long long n, m, k, t, b, mo;
vector<vector<long long>> nm;
long long dp[3005][101][101];
long long l;
struct test {
long long x, y, type;
};
vector<test> a;
long long go(long long fence, long long type, long long br) {
if (fence == 0) return 1;
if (fence < 0) return 0;
if (dp[fence][type][br] != -1) return dp[fence][type][br];
long long ans = 0;
for (long long i = 0; i < a.size(); i++) {
if (a[i].type == type && br == a[i].y) continue;
if (br == -1)
ans = (ans + go(fence - a[i].x, a[i].type, a[i].y)) % mod;
else if (a[i].x == br && a[i].type != type)
ans = (ans + go(fence - a[i].x, a[i].type, a[i].y)) % mod;
}
return dp[fence][type][br] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> l;
for (long long i = 0; i < 3005; i++) {
for (long long j = 0; j < 101; j++) {
for (long long k = 0; k < 101; k++) {
dp[i][j][k] = -1;
}
}
}
for (long long i = 0; i < n; i++) {
long long u, v;
cin >> u >> v;
test f;
f.x = u;
f.y = v;
f.type = i;
if (u != v) {
a.push_back(f);
f.x = v;
f.y = u;
f.type = i;
}
a.push_back(f);
}
cout << go(l, -1, -1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101, maxl = 3001, mod = 1e9 + 7;
int a[maxn], b[maxn], dp[maxl][maxn][2];
int main() {
ios_base::sync_with_stdio(0);
cin.clear();
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++) {
dp[i][j][0] = dp[i][j][1] = 0;
if (i == a[j])
dp[i][j][0] += 1;
else if (i == b[j])
dp[i][j][1] += 1;
for (int k = 0; k < n; k++) {
if (k == j) continue;
if (i > a[j] && a[j] == b[k])
(dp[i][j][0] += dp[i - a[j]][k][0]) %= mod;
if (i > a[j] && a[j] == a[k] && a[k] != b[k])
(dp[i][j][0] += dp[i - a[j]][k][1]) %= mod;
if (a[j] == b[j]) continue;
if (i > b[j] && b[j] == b[k])
(dp[i][j][1] += dp[i - b[j]][k][0]) %= mod;
if (i > b[j] && b[j] == a[k] && a[k] != b[k])
(dp[i][j][1] += dp[i - b[j]][k][1]) %= mod;
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
(ans += dp[l][i][0]) %= mod;
(ans += dp[l][i][1]) %= mod;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fence {
long long w, l, id;
fence() {}
fence(long long ww, long long lll, long long idd) {
w = ww;
l = lll;
id = idd;
}
} fs[3000];
long long n, l, cnt;
long long dp[4000][3000];
const long long mod = 1000000007;
int main() {
cin >> n >> l;
for (long long i = 0; i < n; i++) {
cin >> fs[cnt].w >> fs[cnt].l;
fs[cnt].id = i;
if (fs[cnt].w != fs[cnt].l) {
++cnt;
fs[cnt].w = fs[cnt - 1].l;
fs[cnt].l = fs[cnt - 1].w;
fs[cnt].id = i;
}
cnt++;
}
for (long long i = 0; i < cnt; i++) {
dp[fs[i].w][i] = (dp[fs[i].w][i] + 1) % mod;
}
for (long long i = 1; i <= l; i++) {
for (long long j = 0; j < cnt; j++) {
for (long long k = 0; k < cnt; k++) {
if (fs[j].l == fs[k].w && fs[j].id != fs[k].id && i + fs[k].w <= l) {
dp[i + fs[k].w][k] += dp[i][j];
dp[i + fs[k].w][k] %= mod;
}
}
}
}
long long ans = 0;
for (long long i = 0; i < cnt; i++) {
ans = (ans + dp[l][i]) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Len, a[105][2];
long long dp[105][2][3005];
int main() {
cin >> N >> Len;
for (int i = 0; i < N; i++) {
cin >> a[i][0] >> a[i][1];
}
for (int i = 0; i < N; i++)
if (a[i][0] != a[i][1]) {
dp[i][0][a[i][0]] = 1;
dp[i][1][a[i][1]] = 1;
} else {
dp[i][0][a[i][0]] = 1;
}
for (int l = 1; l < Len; l++) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (i == j) continue;
if (l + a[j][0] <= Len && a[i][1] == a[j][0])
dp[j][0][l + a[j][0]] =
(dp[j][0][l + a[j][0]] + dp[i][0][l] + 0LL) % 1000000007;
if (l + a[j][0] <= Len && a[i][0] == a[j][0])
dp[j][0][l + a[j][0]] =
(dp[j][0][l + a[j][0]] + dp[i][1][l] + 0LL) % 1000000007;
if (a[j][0] == a[j][1]) continue;
if (l + a[j][1] <= Len && a[i][1] == a[j][1])
dp[j][1][l + a[j][1]] =
(dp[j][1][l + a[j][1]] + dp[i][0][l] + 0LL) % 1000000007;
if (l + a[j][1] <= Len && a[i][0] == a[j][1])
dp[j][1][l + a[j][1]] =
(dp[j][1][l + a[j][1]] + dp[i][1][l] + 0LL) % 1000000007;
}
}
}
long long ans = 0;
for (int i = 0; i < N; i++)
ans = (ans + dp[i][0][Len] + dp[i][1][Len] + 0LL) % 1000000007;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int NINF = 0xc0c0c0c0;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const long long maxn = 1e6 + 5;
const int N = 200 + 50;
int n, l, a[N], b[N];
long long f[3500][N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> l;
for (int i = 1; i <= n; i++) {
cin >> 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 && a[k] == b[j])
f[i + a[k]][k] = (f[i + a[k]][k] + f[i][j]) % mod;
}
}
}
long long ans = 0;
for (int i = 1; i <= 2 * n; i++) ans = (ans + f[l][i]) % mod;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101, maxl = 3002, mod = 1e9 + 7;
int dp[maxl][maxn][2], a[maxn], b[maxn];
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++) {
if (i >= a[j]) {
if (i == a[j])
dp[i][j][0] = 1;
else {
for (int k = 0; k < n; k++) {
if (k != j) {
if (a[j] == b[k]) dp[i][j][0] += dp[i - a[j]][k][0];
dp[i][j][0] %= mod;
if (a[j] == a[k]) dp[i][j][0] += dp[i - a[j]][k][1];
dp[i][j][0] %= mod;
}
}
}
}
if (a[j] == b[j] || i < b[j]) continue;
if (i == b[j])
dp[i][j][1] = 1;
else {
for (int k = 0; k < n; k++) {
if (k != j) {
if (b[j] == b[k]) {
dp[i][j][1] += dp[i - b[j]][k][0];
dp[i][j][1] %= mod;
}
if (b[j] == a[k]) {
dp[i][j][1] += dp[i - b[j]][k][1];
dp[i][j][1] %= mod;
}
}
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += dp[l][i][0];
ans %= mod;
ans += dp[l][i][1];
ans %= mod;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SN = 100 + 10;
const int SM = 3000 + 10;
const int MOD = 1000000007;
long long f[SN][SM][2], n, len, a[SN], b[SN], ans;
void Read(long long &x) {
long long in = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
in = in * 10 + ch - '0';
ch = getchar();
}
x = in * f;
}
int main() {
Read(n), Read(len);
for (int i = 1; i <= n; i++) Read(a[i]), Read(b[i]);
for (int i = 1; i <= n; i++) {
f[i][a[i]][0]++;
if (a[i] != b[i]) f[i][b[i]][1]++;
}
for (int k = 1; k <= len; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (k - a[i] >= 0) {
if (a[i] == b[j]) f[i][k][0] = (f[i][k][0] + f[j][k - a[i]][0]) % MOD;
if (a[i] == a[j] && a[j] != b[j])
f[i][k][0] = (f[i][k][0] + f[j][k - a[i]][1]) % MOD;
}
if (a[i] == b[i]) continue;
if (k - b[i] >= 0) {
if (b[i] == b[j]) f[i][k][1] = (f[i][k][1] + f[j][k - b[i]][0]) % MOD;
if (b[i] == a[j] && b[j] != a[j])
f[i][k][1] = (f[i][k][1] + f[j][k - b[i]][1]) % MOD;
}
}
for (int i = 1; i <= n; i++)
if (a[i] != b[i])
ans = (ans + f[i][len][1] + f[i][len][0]) % MOD;
else
ans = (ans + f[i][len][0]) % MOD;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, MAXN = 105, MAXL = 3005;
int N, L, a[MAXN], b[MAXN];
long long int dp[MAXL][MAXN][2];
long long int go(int l, int j, int ar) {
if (l == 0) return 1;
if (dp[l][j][ar] != -1) return dp[l][j][ar];
long long int ans = 0;
int len = a[j];
if (ar) len = b[j];
for (int i = 0; i < N; i++) {
if (i == j) continue;
if (a[i] <= l && a[i] == len) ans = (ans + go(l - a[i], i, 1)) % MOD;
if (a[i] != b[i] && b[i] == len && b[i] <= l)
ans = (ans + go(l - b[i], i, 0)) % MOD;
}
return dp[l][j][ar] = ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> N >> L;
for (int i = 0; i < N; i++) cin >> a[i] >> b[i];
memset(dp, -1, sizeof(dp));
long long int ans = 0;
for (int i = 0; i < N; i++) {
if (a[i] <= L) ans = (ans + go(L - a[i], i, 1)) % MOD;
if (a[i] != b[i] && b[i] <= L) ans = (ans + go(L - b[i], i, 0)) % MOD;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-5;
const int MOD = int(1e9) + 7, MX = int(5e4) + 1;
long long memo[100][3001][2];
int n, l;
pair<int, int> A[101];
long long dp(int i, int len, int f) {
if (len == l) return 1;
if (i == n || len > l) return 0;
long long &ret = memo[i][len][f];
if (ret + 1) return ret;
ret = 0;
int L = A[i].first, W = A[i].second;
if (f) swap(L, W);
for (int j = 0; j < n; j++) {
if (j != i) {
if (A[j].first == W)
ret += dp(j, len + A[j].first, 0);
else if (A[j].second == W)
ret += dp(j, len + A[j].second, 1);
if (ret >= MOD) ret -= MOD;
}
}
return ret;
}
long long sol() {
memset(memo, -1, sizeof memo);
long long res = 0;
for (int i = 0; i < n; i++) {
res += dp(i, A[i].first, 0) +
(A[i].first - A[i].second ? dp(i, A[i].second, 1) : 0);
if (res >= MOD) res -= MOD;
}
return res;
}
void solve() {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; i++) {
scanf("%d %d", &A[i].first, &A[i].second);
}
printf("%lld\n", sol() % MOD);
}
int main() { solve(); }
|
#include <bits/stdc++.h>
struct Seg {
int a, b, id;
} seg[210];
int N, X, L, g[210][210];
long long f[210][3010];
void init() {
int i, j, k;
memset(g, 0, sizeof(g));
N = 0;
for (i = 0; i < X; i++) {
++N;
scanf("%d%d", &seg[N].a, &seg[N].b);
seg[N].id = i;
if (seg[N].a != seg[N].b) {
seg[N + 1].a = seg[N].b, seg[N + 1].b = seg[N].a;
++N;
seg[N].id = i;
}
}
for (i = 1; i <= N; i++)
for (j = 1; j <= N; j++)
if (i != j) {
if (seg[j].a == seg[i].b && seg[j].id != seg[i].id) g[i][j] = 1;
}
}
void solve() {
int i, j, k;
long long ans = 0;
memset(f, 0, sizeof(f));
for (i = 1; i <= N; i++)
if (seg[i].a <= L) f[i][seg[i].a] = 1;
for (k = 1; k <= L; k++)
for (i = 1; i <= N; i++)
if (f[i][k]) {
for (j = 1; j <= N; j++)
if (g[i][j] && k + seg[j].a <= L)
f[j][k + seg[j].a] = (f[j][k + seg[j].a] + f[i][k]) % 1000000007;
}
for (i = 1; i <= N; i++) ans = (ans + f[i][L]) % 1000000007;
printf("%I64d\n", ans);
}
int main() {
while (scanf("%d%d", &X, &L) == 2) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct _ {
_() { ios_base::sync_with_stdio(0); }
} _;
template <class A, class B>
ostream &operator<<(ostream &o, pair<A, B> t) {
o << "(" << t.first << ", " << t.second << ")";
return o;
}
template <class T>
void PV(T a, T b) {
while (a != b) cout << *a++, cout << (a != b ? " " : "\n");
}
template <class T>
inline bool chmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool chmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
string tostring(T first, int len = 0) {
stringstream ss;
ss << first;
string r = ss.str();
if (r.length() < len) r = string(len - r.length(), '0') + r;
return r;
}
template <class T>
void convert(string first, T &r) {
stringstream ss(first);
ss >> r;
}
const int inf = 0x3f3f3f3f;
const int mod = int(1e9) + 7;
const int N = 111111;
int n, L;
int a[110];
int b[110];
int d[222][222];
int w[222];
int can[222];
int s[222][3333];
int used[222][3333];
vector<pair<int, int> > v;
int cnt;
void dfs(int id, int tot) {
if (tot > L) return;
if (tot == L) {
cout << ++cnt << ": ";
PV((v).begin(), (v).end());
return;
}
for (int i = 0; i < n; i++) {
if (id == i) continue;
if (a[i] != b[i] && v.rbegin()->second == b[i]) {
v.push_back(make_pair(b[i], a[i]));
dfs(i, tot + b[i]);
v.pop_back();
}
if (v.rbegin()->second == a[i]) {
v.push_back(make_pair(a[i], b[i]));
dfs(i, tot + a[i]);
v.pop_back();
}
}
}
int main() {
cin >> n >> L;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
can[2 * i] = 1;
w[2 * i] = a[i];
w[2 * i + 1] = b[i];
if (a[i] != b[i]) can[2 * i + 1] = 1;
}
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j < 2 * n; j++) {
if (i / 2 == j / 2 || !can[i] || !can[j]) continue;
if (w[i ^ 1] == w[j]) d[i][j] = 1;
}
for (int i = 0; i < 2 * n; i++) {
if (can[i]) d[2 * n][i] = 1;
}
priority_queue<pair<int, int> > Q;
Q.push(make_pair(0, 2 * n));
s[2 * n][0] = 1;
while (!Q.empty()) {
pair<int, int> cur = Q.top();
Q.pop();
int id = cur.second;
int len = -cur.first;
for (int i = 0; i < 2 * n; i++) {
if (!d[id][i]) continue;
int nextLen = len + w[i];
if (nextLen > L) continue;
if (s[i][nextLen] == 0) Q.push(make_pair(-nextLen, i));
s[i][nextLen] += s[id][len];
if (s[i][nextLen] >= mod) s[i][nextLen] -= mod;
}
}
int res = 0;
for (int i = 0; i <= 2 * n; i++) {
res += s[i][L];
if (res >= mod) res -= mod;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long dp[3010][210];
int n, k, i, j, m, l, len;
int a[210], b[210], c[210];
bool link[210][210];
long long ans;
int main() {
scanf("%d%d", &n, &l);
len = 200;
for (i = 1, m = 0; i <= n; i++) {
m++;
scanf("%d%d", &a[m], &b[m]);
c[m] = i;
if (a[m] != b[m]) {
m++;
a[m] = b[m - 1];
b[m] = a[m - 1];
c[m] = i;
}
if (a[m] < len) len = a[m];
if (b[m] < len) len = b[m];
}
for (i = 1; i <= m; i++)
for (j = 1; j <= m; j++)
if ((b[i] == a[j]) && (c[j] != c[i]))
link[i][j] = 1;
else
link[i][j] = 0;
memset(dp, 0, sizeof(dp));
for (; len <= l; len++)
for (i = 1; i <= m; i++)
if (a[i] == len)
dp[len][i] = 1;
else if (a[i] < len) {
for (j = 1; j <= m; j++)
if (link[j][i]) dp[len][i] += dp[len - a[i]][j];
dp[len][i] %= 1000000007;
}
ans = 0;
for (i = 1; i <= m; i++) ans += dp[l][i];
ans %= 1000000007;
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100];
int b[100];
int f[3001][100][101];
int main() {
int n, l;
scanf("%d", &n);
;
scanf("%d", &l);
;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
;
scanf("%d", &b[i]);
;
f[a[i]][i][b[i]]++;
if (a[i] != b[i]) f[b[i]][i][a[i]]++;
}
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 (i >= b[j]) {
f[i][j][a[j]] += f[i - b[j]][k][b[j]];
if (f[i][j][a[j]] >= 1000000007) f[i][j][a[j]] -= 1000000007;
}
if (a[j] != b[j] && i >= a[j]) {
f[i][j][b[j]] += f[i - a[j]][k][a[j]];
if (f[i][j][b[j]] >= 1000000007) f[i][j][b[j]] -= 1000000007;
}
}
}
}
int r = 0;
for (int j = 0; j < n; j++) {
r += f[l][j][a[j]];
if (r >= 1000000007) r -= 1000000007;
if (a[j] != b[j]) {
r += f[l][j][b[j]];
if (r >= 1000000007) r -= 1000000007;
}
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, l;
pair<int, int> a[111];
int f[3333][111][2];
inline void upd(int ni, int nj, int nk, int i, int j, int k) {
f[ni][nj][nk] = (f[ni][nj][nk] + f[i][j][k]) % mod;
}
int main() {
cin >> n >> l;
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
f[a[i].first][i][0] = 1;
if (a[i].first != a[i].second) f[a[i].second][i][1] = 1;
}
for (int i = 0; i < l; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k) {
if (k != j && a[k].first == a[j].second && i + a[k].first <= l) {
upd(i + a[k].first, k, 0, i, j, 0);
}
if (k != j && a[k].second == a[j].second && i + a[k].second <= l &&
a[k].first != a[k].second) {
upd(i + a[k].second, k, 1, i, j, 0);
}
if (k != j && a[k].first == a[j].first && i + a[k].first <= l) {
upd(i + a[k].first, k, 0, i, j, 1);
}
if (k != j && a[k].second == a[j].first && i + a[k].second <= l &&
a[k].first != a[k].second) {
upd(i + a[k].second, k, 1, i, j, 1);
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans = (ans + f[l][i][0]) % mod;
ans = (ans + f[l][i][1]) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(105);
const int MAXK(4005);
int a[MAXN], b[MAXN];
long long dp[MAXK][MAXN][2];
int main() {
int n, l;
scanf("%d%d", &n, &l);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[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++)
for (int p = 0; p < n; p++) {
if (p == j) continue;
int width;
if (k == 0)
width = b[j];
else
width = a[j];
if (a[p] == width) {
dp[i + a[p]][p][0] += dp[i][j][k];
dp[i + a[p]][p][0] %= MOD;
}
if (a[p] != b[p] && b[p] == width) {
dp[i + b[p]][p][1] += dp[i][j][k];
dp[i + b[p]][p][1] %= MOD;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) ans = (ans + dp[l][i][0] + dp[l][i][1]) % MOD;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l, a[111][3111][2], i, j, w[111], h[111], s, ans = 0, base = 1000000007;
int main() {
cin >> n >> s;
for (i = 0; i < n; i++) {
cin >> w[i] >> h[i];
a[i][w[i]][0] = 1;
if (h[i] != w[i]) a[i][h[i]][1] = 1;
}
for (i = 0; i < s; i++)
for (j = 0; j < n; j++) {
if (a[j][i][0])
for (l = 0; l < n; l++) {
if (l == j) continue;
if ((h[j] == w[l]) && (i + w[l] <= s))
a[l][i + w[l]][0] = (a[l][i + w[l]][0] + a[j][i][0]) % base;
if ((h[j] == h[l]) && (i + h[l] <= s) && (w[l] != h[l]))
a[l][i + h[l]][1] = (a[l][i + h[l]][1] + a[j][i][0]) % base;
}
if (a[j][i][1])
for (l = 0; l < n; l++) {
if (l == j) continue;
if ((w[j] == w[l]) && (i + w[l] <= s))
a[l][i + w[l]][0] = (a[l][i + w[l]][0] + a[j][i][1]) % base;
if ((w[j] == h[l]) && (i + h[l] <= s) && (w[l] != h[l]))
a[l][i + h[l]][1] = (a[l][i + h[l]][1] + a[j][i][1]) % base;
}
}
for (i = 0; i < n; i++)
for (j = 0; j < 2; j++) ans = (ans + a[i][s][j]) % base;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
pair<int, int> B[205];
long long mod = 1000000007;
long long dp[205][3000 + 2];
bool vst[205][3000 + 2];
vector<int> adj[205];
int tp[205];
long long go(int last, int len) {
if (len > l) return 0;
long long &ret = dp[last][len];
if (vst[last][len]) return ret;
vst[last][len] = true;
if (len == l) return ret = 1;
ret = 0;
int sz = ((int)(adj[last]).size()), i, j;
for (i = 0; i < (sz); i++) {
j = adj[last][i];
ret += go(j, len + B[j].first);
ret %= mod;
}
return ret;
}
int main() {
int i;
cin >> n >> l;
int a, b, j = 0;
for (i = 0; i < (n); i++) {
cin >> a >> b;
tp[j] = i;
B[j++] = make_pair(a, b);
if (a != b) {
tp[j] = i;
B[j++] = make_pair(b, a);
}
}
long long ans = 0;
int tot = j;
for (i = 0; i < (tot); i++) {
for (j = 0; j < (tot); j++) {
if (i == j) continue;
if (tp[i] == tp[j]) continue;
if (B[i].second == B[j].first) adj[i].push_back(j);
}
}
for (i = 0; i < (tot); i++) {
ans += go(i, B[i].first);
ans %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LINF = (long long)1e18;
const int maxL = 3333;
const int maxN = 211;
int dp[maxL][maxN];
const int MOD = (long long)1e9 + 7;
int a[maxN];
int b[maxN];
void add(int &a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
}
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> a[i * 2] >> b[i * 2];
if (a[i * 2] != b[i * 2]) {
b[i * 2 + 1] = a[i * 2];
a[i * 2 + 1] = b[i * 2];
}
}
for (int i = 0; i < 2 * n; i++) {
if (a[i]) dp[a[i]][i] = 1;
}
for (int ii = 0; ii <= l; ii++) {
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < 2 * n; j++) {
if (i / 2 == j / 2 || !a[i] || !a[j]) continue;
if (a[i] == b[j]) {
add(dp[ii + a[j]][j], dp[ii][i]);
}
}
}
}
int ans = 0;
for (int i = 0; i < maxN; i++) {
add(ans, dp[l][i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[3001][100][2];
const long long MOD = 1000000007;
int a[100], b[100];
int L, n;
int main() {
while (scanf("%d%d", &n, &L) != EOF) {
memset(dp, 0, sizeof dp);
map<int, vector<int> > index;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i], &b[i]);
dp[a[i]][i][0] = 1;
if (a[i] != b[i]) dp[b[i]][i][1] = 1;
map<int, vector<int> >::iterator it = index.find(a[i]);
if (index.end() == it) {
vector<int> vec;
vec.push_back(i);
index[a[i]] = vec;
} else {
it->second.push_back(i);
}
it = index.find(b[i]);
if (index.end() == it) {
vector<int> vec;
vec.push_back(i);
index[b[i]] = vec;
} else {
if (b[i] != a[i]) it->second.push_back(i);
}
}
for (int l = 0; l <= L; ++l) {
for (int i = 0; i < n; ++i) {
for (int t = 0; t < 2; ++t) {
int B = t == 1 ? a[i] : b[i];
int A = a[i] + b[i] - B;
map<int, vector<int> >::iterator it = index.find(B);
if (index.end() == it) {
continue;
}
const vector<int>& arr = it->second;
for (int j = 0; j < arr.size(); ++j) {
if (a[arr[j]] == B && l + a[arr[j]] <= L && i != arr[j]) {
dp[l + a[arr[j]]][arr[j]][0] =
(dp[l + a[arr[j]]][arr[j]][0] + dp[l][i][t]) % MOD;
} else if (b[arr[j]] == B && l + b[arr[j]] <= L && i != arr[j]) {
dp[l + b[arr[j]]][arr[j]][1] =
(dp[l + b[arr[j]]][arr[j]][1] + dp[l][i][t]) % MOD;
}
}
}
}
}
long long sum = 0;
for (int i = 0; i < n; ++i) {
sum = (sum + dp[L][i][0] + dp[L][i][1]) % MOD;
}
cout << sum << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int PD[3003][128][2];
int a[128], b[128];
int n, l;
inline int mod(int n) { return n < 1000000007 ? n : (n - 1000000007); }
int calc(int l, int ult, int inv) {
if (l < 0) return 0;
if (l == 0) return 1;
int &pd = PD[l][ult][inv];
if (pd != -1) return pd;
int soma = 0;
int prim = (inv == 0 ? b[ult] : a[ult]);
for (int i = 0; i < n; i++)
if (i != ult) {
if (a[i] == prim) soma = mod(soma + calc(l - a[i], i, 0));
if (b[i] == prim and b[i] != a[i])
soma = mod(soma + calc(l - b[i], i, 1));
}
return pd = soma;
}
int main() {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; i++) scanf("%d %d", a + i, b + i);
memset(PD, 0xff, sizeof(PD));
int soma = 0;
for (int i = 0; i < n; i++) {
soma = mod(soma + calc(l - a[i], i, 0));
if (a[i] != b[i]) soma = mod(soma + calc(l - b[i], i, 1));
}
printf("%d\n", soma);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long n, l, a[3001][101][2], ans;
pair<long long, long long> b[101];
int main() {
long long i, j, k;
cin >> n >> l;
for (i = 1; i <= n; i++) {
cin >> b[i].first >> b[i].second;
if (b[i].second < b[i].first) swap(b[i].first, b[i].second);
a[b[i].first][i][1]++;
a[b[i].second][i][0]++;
}
for (i = 0; i <= l; i++) {
for (j = 1; j <= n; j++) {
for (k = 1; k <= n; k++) {
if (k == j) continue;
if (b[k].first == b[j].first) {
if (i - b[j].first > 0)
a[i][j][1] = (a[i][j][1] + a[i - b[j].first][k][0]) % mod;
}
if (b[k].second != b[k].first && b[k].second == b[j].first) {
if (i - b[j].first > 0)
a[i][j][1] = (a[i][j][1] + a[i - b[j].first][k][1]) % mod;
}
if (b[k].first == b[j].second) {
if (i - b[j].second > 0)
a[i][j][0] = (a[i][j][0] + a[i - b[j].second][k][0]) % mod;
}
if (b[k].second != b[k].first && b[k].second == b[j].second) {
if (i - b[j].second > 0)
a[i][j][0] = (a[i][j][0] + a[i - b[j].second][k][1]) % mod;
}
}
}
}
for (i = 1; i <= n; i++) {
ans = (ans + a[l][i][0]) % mod;
if (b[i].first != b[i].second) ans = (ans + a[l][i][1]) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 3000 + 10;
long long int MOD = (1e+9) + 7;
long long int dp[2 * M][200 + 10];
struct BOARD {
long long int l, w;
int type;
} board[M];
int main() {
int n, l;
cin >> n >> l;
int num = 0;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a == b) {
board[num].l = a;
board[num].w = a;
board[num].type = i;
num++;
} else {
board[num].l = a;
board[num].w = b;
board[num].type = i;
num++;
board[num].l = b;
board[num].w = a;
board[num].type = i;
num++;
}
}
for (int i = 0; i < num; i++) {
dp[board[i].l][i] = 1;
}
for (int row = 1; row < l; row++) {
for (int col = 0; col < num; col++) {
for (int j = 0; j < num; j++) {
if (board[j].type != board[col].type && board[j].l == board[col].w) {
dp[row + board[j].l][j] =
(dp[row + board[j].l][j] + dp[row][col]) % MOD;
}
}
}
}
long long int ans = 0;
for (int i = 0; i < num; i++) {
ans = (ans + dp[l][i]) % MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tostr(const T& t) {
ostringstream os;
os << t;
return os.str();
}
int N, L;
long long MOD = 1000000007;
typedef struct {
int length;
int width;
} typeboard;
vector<typeboard> boards;
int memo[110][110][3010];
int go(int prevType, int prevWidth, int totLen) {
if (totLen == L) return 1LL;
if (totLen > L) return 0LL;
int& ref = memo[prevType][prevWidth][totLen];
if (ref != -1) return ref;
ref = 0;
if (prevWidth == 0) {
for (int i = (int)(0); i <= (int)(N - 1); ++i) {
ref = (ref + go(i, boards[i].width, boards[i].length)) % MOD;
if (boards[i].length != boards[i].width)
ref = (ref + go(i, boards[i].length, boards[i].width)) % MOD;
}
} else {
for (int i = (int)(0); i <= (int)(N - 1); ++i) {
if (i == prevType) continue;
if (boards[i].length == prevWidth) {
ref = (ref + go(i, boards[i].width, totLen + boards[i].length)) % MOD;
} else if (boards[i].width == prevWidth) {
ref = (ref + go(i, boards[i].length, totLen + boards[i].width)) % MOD;
}
}
}
return ref;
}
int main() {
cin >> N >> L;
for (int i = (int)(0); i <= (int)(N - 1); ++i) {
typeboard board;
cin >> board.length >> board.width;
boards.push_back(board);
}
memset(memo, -1, sizeof memo);
long long ans = go(0, 0, 0) % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infll = 0x3f3f3f3f3f3f3f3f;
const long long mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int maxn = 1e5 + 5;
const int maxm = 1.5e7 + 5;
using namespace std;
int n, l;
int a[300], b[300];
long long dp[5000][300];
long long ans;
int main() {
cin >> n >> l;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> 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 (int i = 1; i <= l; i++) {
for (int j = 0; j < 2 * n; j++) {
if (!dp[i][j]) continue;
for (int 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]) % mod;
}
}
}
}
for (int i = 0; i < 2 * n; i++) {
ans = (ans + dp[l][i]) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int M = 1000000000 + 7;
int n, l, a[2][100];
long long 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 = 0; i < 2; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < 2; ++k) dp[i][j][k] = 0;
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])
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;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct node {
int x, y, k;
} a[205];
long long f[3005][205];
int main() {
int n, l, tot = 1;
scanf("%d%d", &n, &l);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[tot].x, &a[tot].y);
a[tot].k = i;
if (a[tot].x != a[tot].y) {
tot++;
a[tot].x = a[tot - 1].y;
a[tot].y = a[tot - 1].x;
a[tot].k = i;
}
tot++;
}
for (int i = 1; i <= l; i++) {
for (int j = 1; j < tot; j++) {
for (int k = 0; k < tot; k++) {
if (a[j].k == a[k].k) {
continue;
}
if (k == 0 && a[j].x == i) {
f[i][j]++;
f[i][j] %= mod;
} else if (a[j].x == a[k].y && i > a[j].x) {
f[i][j] += f[i - a[j].x][k];
f[i][j] %= mod;
}
}
}
}
long long ans = 0;
for (int i = 1; i < tot; i++) {
ans = (ans + f[l][i]) % mod;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5e3;
const int mod = 1e9 + 7;
int n, m, a[maxN], b[maxN];
long long dp[maxN][maxN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("test.inp", "r")) freopen("test.inp", "r", stdin);
cin >> n >> m;
memset(dp, 0, sizeof dp);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
dp[a[i]][i]++;
if (a[i] != b[i]) {
dp[b[i]][i + n]++;
a[i + n] = b[i];
b[i + n] = a[i];
}
}
for (int i = 0; i <= m; i++) {
for (int j = 0; j < 2 * n; j++) {
for (int k = 0; k < 2 * n; k++) {
if (!dp[i][k]) continue;
if (b[k] == a[j] && (j % n != k % n)) dp[i + a[j]][j] += dp[i][k];
dp[i + a[j]][j] %= mod;
}
}
}
long long res = 0;
for (int i = 0; i < 2 * n; i++) {
res += dp[m][i];
res %= mod;
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
const int maxl = 3000 + 100;
int n, k;
long long dp[maxn][maxl][2], a[maxn], b[maxn], inf = 1000 * 1000 * 1000 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
for (int i = 1; i <= n; i++) {
dp[i][a[i]][0] = 1;
if (a[i] != b[i]) {
dp[i][b[i]][1] = 1;
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
if (a[j] <= i)
for (int l = 1; l <= n; l++)
if (l != j) {
if (a[j] == b[l])
dp[j][i][0] = (dp[j][i][0] + dp[l][i - a[j]][0]) % inf;
if (a[j] == a[l])
dp[j][i][0] = (dp[j][i][0] + dp[l][i - a[j]][1]) % inf;
}
if (a[j] != b[j] && b[j] <= i)
for (int l = 1; l <= n; l++)
if (l != j) {
if (b[j] == a[l])
dp[j][i][1] = (dp[j][i][1] + dp[l][i - b[j]][1]) % inf;
if (b[j] == b[l])
dp[j][i][1] = (dp[j][i][1] + dp[l][i - b[j]][0]) % inf;
}
}
}
long long res = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 2; j++) res += dp[i][k][j];
cout << res % inf << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 105;
const int L = 3005;
int a[N][2];
int val[N][2][L];
int main() {
int n, m, i, j, k, x, y, ans;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d%d", &a[i][0], &a[i][1]);
}
for (i = 1; i <= n; i++) {
val[i][0][a[i][1]] = 1;
if (a[i][0] != a[i][1]) val[i][1][a[i][0]] = 1;
}
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) {
x = a[j][0], y = a[j][1];
if (i > y) {
int &ret = val[j][0][i];
for (k = 1; k <= n; k++)
if (k != j) {
if (a[k][0] == y)
ret = (ret + val[k][0][i - y]) % MOD;
else if (a[k][1] == y)
ret = (ret + val[k][1][i - y]) % MOD;
}
}
if (x != y && i > x) {
int &ret = val[j][1][i];
for (k = 1; k <= n; k++)
if (k != j) {
if (a[k][0] == x)
ret = (ret + val[k][0][i - x]) % MOD;
else if (a[k][1] == x)
ret = (ret + val[k][1][i - x]) % MOD;
}
}
}
}
ans = 0;
for (i = 1; i <= n; i++) {
ans = (ans + val[i][0][m]) % MOD;
if (a[i][0] != a[i][1]) ans = (ans + val[i][1][m]) % MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double eps = 1e-15;
const int mod = 1000000007;
long long dp[3110][220];
struct node {
int l, w;
int ty;
} data[220];
int main() {
int n, l;
while (~scanf("%d%d", &n, &l)) {
int a, b;
int cnt = 0;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a, &b);
data[++cnt].l = a;
data[cnt].w = b;
data[cnt].ty = i;
dp[a][cnt] = 1;
if (a != b) {
data[++cnt].l = b;
data[cnt].w = a;
data[cnt].ty = i;
dp[b][cnt] = 1;
}
}
for (int i = 1; i <= l; ++i) {
for (int j = 1; j <= cnt; ++j) {
if (dp[i][j]) {
for (int k = 1; k <= cnt; ++k) {
if (data[k].ty == data[j].ty) {
continue;
}
if (data[k].l == data[j].w) {
dp[i + data[k].l][k] += dp[i][j];
dp[i + data[k].l][k] %= mod;
}
}
}
}
}
long long ans = 0;
for (int i = 1; i <= cnt; ++i) {
ans += dp[l][i];
ans %= mod;
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int n, l, b[103][2];
long long pd[103][2][3003];
long long rec(int t, int k, int len) {
if (len > l)
return 0;
else if (len == l)
return 1;
if (pd[t][k][len] != -1) return pd[t][k][len];
long long res = 0;
for (int i = 0; i < n; ++i) {
if (i == t) continue;
if (b[i][1] == (k ? b[t][1] : b[t][0])) {
res += rec(i, 0, len + b[i][1]);
}
if (b[i][0] != b[i][1] && b[i][0] == (k ? b[t][1] : b[t][0])) {
res += rec(i, 1, len + b[i][0]);
}
if (res >= MOD) res %= MOD;
}
return pd[t][k][len] = res;
}
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) scanf("%d%d", &b[i][0], &b[i][1]);
memset(pd, -1, sizeof(pd));
long long res = 0;
for (int i = 0; i < n; ++i) {
res += rec(i, 0, b[i][1]);
if (b[i][0] != b[i][1]) res += rec(i, 1, b[i][0]);
res %= MOD;
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000 + 100;
int dp[maxn][100 + 20][2];
int a[100 + 20], b[100 + 20];
const int mod = 1e9 + 7;
void MOD(int& x) { x %= mod; }
int main() {
int n, l;
while (scanf("%d %d", &n, &l) != EOF) {
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i], &b[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++) {
if (a[j] <= i) {
for (int k = 1; (k <= n); k++) {
if (k == j) continue;
if (a[j] == a[k]) {
dp[i][j][0] += dp[i - a[j]][k][1];
MOD(dp[i][j][0]);
}
if (a[j] == b[k]) {
dp[i][j][0] += dp[i - a[j]][k][0];
MOD(dp[i][j][0]);
}
}
}
if (b[j] <= i && b[j] != a[j]) {
for (int k = 1; (k <= n); k++) {
if (k == j) continue;
if (b[j] == a[k]) {
dp[i][j][1] += dp[i - b[j]][k][1];
MOD(dp[i][j][1]);
}
if (b[j] == b[k]) {
dp[i][j][1] += dp[i - b[j]][k][0];
MOD(dp[i][j][1]);
}
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += dp[l][i][0];
MOD(ans);
ans += dp[l][i][1];
MOD(ans);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NN = 222, LEN = 3009, MOD = 1000000007;
bool v[NN][LEN];
int dp[NN][LEN];
bool dp_bool[NN][LEN];
bool v_bool[NN][LEN];
int n, org_len;
int type[NN];
struct node {
int type, len, width;
node(){};
};
node board[NN];
int rec(int pos, int len) {
if (len == 0) return 1;
if (v[pos][len] == true) return dp[pos][len];
v[pos][len] = true;
int &res = dp[pos][len];
res = 0;
for (int i = 0; i < n; i++)
if (board[i].type != board[pos].type && board[i].len == board[pos].width) {
if (i % 2 && board[i].len == board[i].width) continue;
if (len - board[i].len >= 0) {
res += rec(i, len - board[i].len);
if (res >= MOD) res -= MOD;
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
scanf("%d%d", &n, &org_len);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
board[i * 2].type = i;
board[i * 2].len = a;
board[i * 2].width = b;
board[i * 2 + 1].type = i;
board[i * 2 + 1].len = b;
board[i * 2 + 1].width = a;
}
n <<= 1;
memset(v, 0, sizeof(v));
int ans = 0;
for (int i = 0; i < n; i++)
if (org_len - board[i].len >= 0) {
if (i % 2 && board[i].len == board[i].width) continue;
ans += rec(i, org_len - board[i].len);
if (ans >= MOD) ans -= MOD;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const double eps = 1e-15;
const int mod = 1000000007;
long long dp[3110][220];
struct node {
int l, w;
int ty;
} data[220];
int main() {
int n, l;
while (~scanf("%d%d", &n, &l)) {
int a, b;
int cnt = 0;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a, &b);
data[++cnt].l = a;
data[cnt].w = b;
data[cnt].ty = i;
dp[a][cnt] = 1;
if (a != b) {
data[++cnt].l = b;
data[cnt].w = a;
data[cnt].ty = i;
dp[b][cnt] = 1;
}
}
for (int i = 1; i <= l; ++i) {
for (int j = 1; j <= cnt; ++j) {
if (dp[i][j]) {
for (int k = 1; k <= cnt; ++k) {
if (data[k].ty == data[j].ty) {
continue;
}
if (data[k].l == data[j].w) {
dp[i + data[k].l][k] += dp[i][j];
dp[i + data[k].l][k] %= mod;
}
}
}
}
}
long long ans = 0;
for (int i = 1; i <= cnt; ++i) {
ans += dp[l][i];
ans %= mod;
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const long long maxn = 210;
const long long maxl = 3100;
const long long mod = 1e9 + 7;
pair<long long, long long> a[maxn];
long long q[maxn];
long long dp[maxl][maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, l;
cin >> n >> l;
for (long long i = 0; i < n; i++) {
long long u, v;
cin >> u >> v;
if (v == u) {
a[i] = make_pair(v, u);
q[i] = maxn;
} else {
a[i] = make_pair(v, u);
q[i] = i + 1;
i++;
n++;
a[i] = make_pair(u, v);
q[i] = i - 1;
}
}
for (long long i = 1; i <= l; i++) {
for (long long j = 0; j < n; j++) {
if (a[j].first == i) {
dp[i][j] = 1;
} else if (a[j].first < i) {
for (long long p = 0; p < n; p++) {
if (p != j && q[j] != p && a[j].first == a[p].second) {
dp[i][j] += dp[i - a[j].first][p];
dp[i][j] %= mod;
}
}
}
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += dp[l][i];
ans %= mod;
}
cout << ans;
}
|
#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, int 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;
f = !f;
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);
}
if (ret >= moduolo) 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);
if (res >= moduolo) res -= moduolo;
if (boards[i][0] == boards[i][1]) {
break;
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 128;
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
int dp[3001][101][2];
int a[101], b[101];
int main() {
int i, j, k;
int n, l;
while (scanf("%d %d", &n, &l) != EOF) {
memset(dp, 0, sizeof(dp));
for (i = 0; i < n; i++) {
scanf("%d %d", &a[i], &b[i]);
dp[a[i]][i][0] = 1;
dp[b[i]][i][1] = 1;
}
for (i = 1; i < l; i++) {
for (j = 0; j < n; j++) {
if (a[j] == b[j]) {
dp[i][j][1] = 0;
}
for (k = 0; k < n; k++)
if (k != j) {
if (a[j] == a[k] && i + a[k] <= l) {
dp[i + a[k]][k][0] += dp[i][j][1];
dp[i + a[k]][k][0] %= 1000000007;
}
if (a[j] == b[k] && i + b[k] <= l) {
dp[i + b[k]][k][1] += dp[i][j][1];
dp[i + b[k]][k][1] %= 1000000007;
}
if (b[j] == a[k] && i + a[k] <= l) {
dp[i + a[k]][k][0] += dp[i][j][0];
dp[i + a[k]][k][0] %= 1000000007;
}
if (b[j] == b[k] && i + b[k] <= l) {
dp[i + b[k]][k][1] += dp[i][j][0];
dp[i + b[k]][k][1] %= 1000000007;
}
}
}
}
int ans = 0;
for (i = 0; i < n; i++) {
ans += dp[l][i][0];
ans %= 1000000007;
if (a[i] == b[i]) continue;
ans += dp[l][i][1];
ans %= 1000000007;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
bool visit[100001];
const int mod = 1000000007;
long long mod_mult(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long mult(long long x, long long y) {
long long prod = 1;
while (y > 0) {
if (y & 1) prod = mod_mult(prod, x);
x = mod_mult(x, x);
y /= 2;
}
return prod;
}
long long dp[3002][102][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i, l;
vector<pair<long long, long long> > v;
pair<long long, long long> p;
cin >> n >> l;
for (long long i = 0; i < n; i += 1)
cin >> p.first >> p.second, v.push_back(p);
for (int i = 0; i < n; i++) {
dp[v[i].second][i][1] = 1;
if (v[i].first != v[i].second) dp[v[i].first][i][0] = 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) continue;
if (v[k].first == v[j].second && i - v[j].second >= 0)
dp[i][j][1] =
(dp[i][j][1] % mod + dp[i - v[j].second][k][1] % mod) % mod;
else if (v[k].second == v[j].second && i - v[j].second >= 0)
dp[i][j][1] =
(dp[i][j][1] % mod + dp[i - v[j].second][k][0] % mod) % mod;
if (v[j].first == v[j].second) continue;
if (v[k].first == v[j].first && i - v[j].first >= 0)
dp[i][j][0] =
(dp[i][j][0] % mod + dp[i - v[j].first][k][1] % mod) % mod;
else if (v[k].second == v[j].first && i - v[j].first >= 0)
dp[i][j][0] =
(dp[i][j][0] % mod + dp[i - v[j].first][k][0] % mod) % mod;
dp[i][j][0] %= mod;
dp[i][j][1] %= mod;
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) ans = (ans % mod + dp[l][i][j] % mod) % mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int a[205][3];
int res[3005][205];
int main(void) {
int n, l;
scanf("%d%d", &n, &l);
int k = n;
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i][0], &a[i][1]);
a[i][2] = i;
if (a[i][0] != a[i][1]) {
a[k][0] = a[i][1];
a[k][1] = a[i][0];
a[k++][2] = i;
}
}
for (int i = 0; i < k; i++) res[0][i] = 1;
for (int i = 1; i <= l; i++) {
for (int j = 0; j < k; j++) {
res[i][j] = 0;
if (i < a[j][0]) continue;
if (i == a[j][0]) {
res[i][j] = 1;
continue;
}
for (int m = 0; m < k; m++)
if (a[j][2] != a[m][2] && a[j][0] == a[m][1]) {
res[i][j] = (res[i][j] + res[i - a[j][0]][m]) % 1000000007;
}
}
}
int sum = 0;
for (int i = 0; i < 2 * n; i++) sum = (sum + res[l][i]) % 1000000007;
printf("%d", sum);
return 0;
}
|
#include <bits/stdc++.h>
const long double eps = 1e-9;
const double pi = acos(-1.0);
const long long inf = 1e18;
const int mod = 1000000007;
using namespace std;
int f[3333][101][2], a[111], b[111], n, len;
int main(int argc, const char* argv[]) {
cin >> n >> len;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
f[a[i]][i][0]++;
if (a[i] != b[i]) f[b[i]][i][1]++;
}
for (int i = 0; i <= len; i++)
for (int j = 1; j <= n; j++) {
if (f[i][j][0] != 0) {
for (int k = 1; k <= n; k++) {
if (k == j) continue;
if (a[k] == b[j]) {
f[i + a[k]][k][0] += f[i][j][0];
f[i + a[k]][k][0] %= mod;
}
if (b[k] == b[j] && a[k] != b[k]) {
f[i + b[k]][k][1] += f[i][j][0];
f[i + b[k]][k][1] %= mod;
}
}
}
if (f[i][j][1] != 0) {
for (int k = 1; k <= n; k++) {
if (k == j) continue;
if (a[k] == a[j]) {
f[i + a[k]][k][0] += f[i][j][1];
f[i + a[k]][k][0] %= mod;
}
if (b[k] == a[j] && a[k] != b[k]) {
f[i + b[k]][k][1] += f[i][j][1];
f[i + b[k]][k][1] %= mod;
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += (f[len][i][0] + f[len][i][1]) % mod;
ans %= mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 110;
const int mod = 1e9 + 7;
int dp[maxn][310];
int a[310], b[310];
int main() {
int l, n, x, y, ans = 0;
cin >> n >> l;
for (int i = 1; i <= n; i++) {
cin >> 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 (int i = 1; i <= l; i++) {
for (int j = 1; j <= n * 2; j++) {
if (!dp[i][j]) continue;
for (int k = 1; k <= n * 2; k++) {
if ((j % n) != (k % n) && b[j] == a[k])
dp[i + a[k]][k] = (dp[i + a[k]][k] + dp[i][j]) % mod;
}
}
}
for (int i = 1; i <= 2 * n; i++) ans = (ans + dp[l][i]) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inf = 1000000007;
int f[300005][105][2];
struct point {
int x, y;
} a[105];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = 1; i <= m; i++) {
for (int j = 0; j < n; j++) {
if (a[j].x == i)
f[i][j][0] = 1;
else {
if (a[j].x < i)
for (int k = 0; k < n; k++)
if (k != j) {
if (a[k].y == a[j].x)
f[i][j][0] = (f[i][j][0] + f[i - a[j].x][k][0]) % inf;
if (a[k].x == a[j].x)
f[i][j][0] = (f[i][j][0] + f[i - a[j].x][k][1]) % inf;
}
}
if (a[j].x != a[j].y) {
if (a[j].y == i)
f[i][j][1] = 1;
else {
if (a[j].y < i)
for (int k = 0; k < n; k++)
if (k != j) {
if (a[k].y == a[j].y)
f[i][j][1] = (f[i][j][1] + f[i - a[j].y][k][0]) % inf;
if (a[k].x == a[j].y)
f[i][j][1] = (f[i][j][1] + f[i - a[j].y][k][1]) % inf;
}
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j <= 1; j++) ans = (ans + f[m][i][j]) % inf;
cout << ans % inf;
ans--;
ans++;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 120;
int x[N], y[N];
int f[3020][N][N];
const int mod = 1e9 + 7;
int main() {
int n, l;
scanf("%d%d", &n, &l);
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= n; j++) {
if (x[j] == i) f[i][j][0] = 1;
if (x[j] != y[j] && y[j] == i) f[i][j][1] = 1;
for (int k = 1; k <= n; k++)
if (k != j) {
if (x[j] == y[k] && i >= x[j])
f[i][j][0] = (f[i][j][0] + f[i - x[j]][k][0]) % mod;
if (x[j] == x[k] && i >= x[j])
f[i][j][0] = (f[i][j][0] + f[i - x[j]][k][1]) % mod;
if (x[j] != y[j] && i >= y[j]) {
if (y[j] == y[k])
f[i][j][1] = (f[i][j][1] + f[i - y[j]][k][0]) % mod;
if (y[j] == x[k])
f[i][j][1] = (f[i][j][1] + f[i - y[j]][k][1]) % mod;
}
}
}
}
int ans = 0;
for (int j = 1; j <= n; j++)
ans += (f[l][j][0] + f[l][j][1]) % mod, ans %= mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const long long MOD = 1e9 + 7;
long long dp[3500][300];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, l;
cin >> n >> l;
vector<pair<int, int>> v;
vector<int> type;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (x <= l) {
v.push_back({x, y});
type.push_back(i);
}
if (x != y && y <= l) {
v.push_back({y, x});
type.push_back(i);
}
}
n = v.size();
for (int i = 0; i < n; i++) {
dp[v[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] && v[j].first == v[k].second) {
if (v[j].first + v[k].first <= i) {
dp[i][j] = (dp[i][j] + dp[i - v[j].first][k]) % MOD;
}
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + dp[l][i]) % MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 1e6 + 7, SM = 1e3 + 5, logN = 20;
const long long MOD = 1e9 + 7, INF = 1e18 + 9;
const int dx[] = {1, 0, 0, -1, -1, 1, -1, 1};
const int dy[] = {0, 1, -1, 0, -1, 1, 1, -1};
void debug() { cerr << "\n"; }
template <typename Head, typename... Tail>
void debug(Head a, Tail... b) {
cerr << a << " ";
debug(b...);
}
long long n, l, a[105], b[105], dp[SM * 4][105][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> l;
for (long long i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
dp[a[i]][i][0]++;
if (a[i] != b[i]) dp[b[i]][i][1]++;
}
for (long long len = 0; len <= l; len++) {
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
if (i == j) continue;
if (b[i] == a[j]) {
(dp[len + a[j]][j][0] += dp[len][i][0]) %= MOD;
}
if (a[i] != b[i] && a[i] == a[j]) {
(dp[len + a[j]][j][0] += dp[len][i][1]) %= MOD;
}
if (a[j] != b[j] && b[i] == b[j]) {
(dp[len + b[j]][j][1] += dp[len][i][0]) %= MOD;
}
if (a[i] != b[i] && a[j] != b[j] && a[i] == b[j]) {
(dp[len + b[j]][j][1] += dp[len][i][1]) %= MOD;
}
}
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
(ans += dp[l][i][0]) %= MOD;
(ans += dp[l][i][1]) %= MOD;
}
cout << ans;
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500009;
const int mod = 1000000007;
long long int dp[101][2][3001];
long long int a[101], b[101];
void pre() {
for (long long int i = 0; i < 101; i++) {
for (long long int j = 0; j < 3001; j++) {
dp[i][0][j] = dp[i][1][j] = 0;
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
pre();
long long int n, l;
cin >> n >> l;
for (long long int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
for (long long int i = 1; i <= l; i++) {
for (long long int j = 1; j <= n; j++) {
for (long long int k = 0; k < 2; k++) {
if (k == 0) {
if (a[j] == i) {
dp[j][0][i] = 1;
continue;
} else if (a[j] > i) {
continue;
}
} else {
if (b[j] == i && a[j] != b[j]) {
dp[j][1][i] = 1;
continue;
} else if (b[j] > i) {
continue;
}
}
for (long long int ji = 1; ji <= n; ji++) {
for (long long int ki = 0; ki < 2; ki++) {
if (j == ji) continue;
if (k == 0) {
if (ki == 0) {
if (a[j] == b[ji]) {
dp[j][k][i] += dp[ji][ki][i - a[j]];
dp[j][k][i] %= mod;
}
} else {
if (a[j] == a[ji]) {
dp[j][k][i] += dp[ji][ki][i - a[j]];
dp[j][k][i] %= mod;
}
}
} else if (a[j] != b[j]) {
if (ki == 0) {
if (b[j] == b[ji]) {
dp[j][k][i] += dp[ji][ki][i - b[j]];
dp[j][k][i] %= mod;
}
} else {
if (b[j] == a[ji]) {
dp[j][k][i] += dp[ji][ki][i - b[j]];
dp[j][k][i] %= mod;
}
}
}
}
}
}
}
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
ans += (dp[i][0][l] + dp[i][1][l]) % mod;
ans %= mod;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int LEN = 3105, SIDE = 105, mod = 1e9 + 7, N = 105;
int dp[LEN][SIDE][N], side;
void solve() {
int n, len;
cin >> n >> len;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
dp[a[i]][b[i]][i] = 1;
dp[b[i]][a[i]][i] = 1;
}
for (int l = 0; l <= len; l++) {
for (int i = 0; i < n; i++) {
for (int prev = 0; prev < n; prev++) {
if (i == prev) continue;
side = a[prev];
if (a[i] == side) {
dp[l + a[i]][b[i]][i] =
(dp[l + a[i]][b[i]][i] + dp[l][side][prev]) % mod;
}
if (b[i] != a[i] && b[i] == side) {
dp[l + b[i]][a[i]][i] =
(dp[l + b[i]][a[i]][i] + dp[l][side][prev]) % mod;
}
side = b[prev];
if (side == a[prev]) continue;
if (a[i] == side) {
dp[l + a[i]][b[i]][i] =
(dp[l + a[i]][b[i]][i] + dp[l][side][prev]) % mod;
}
if (b[i] != a[i] && b[i] == side) {
dp[l + b[i]][a[i]][i] =
(dp[l + b[i]][a[i]][i] + dp[l][side][prev]) % mod;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++)
for (int side = 0; side <= 100; side++)
ans = (ans + dp[len][side][i]) % mod;
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, l;
cin >> n >> l;
unsigned long long d[l + 1][n][2];
memset(d, 0, sizeof(d));
vector<pair<int, int>> a(n);
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 (i - a[j].first == 0) d[i][j][0]++;
if (a[j].first != a[j].second && i - a[j].second == 0) d[i][j][1]++;
for (int k = 0; k < n; ++k) {
if (j == k) continue;
if (a[j].first == a[k].first && i - a[j].first > 0)
d[i][j][0] = (d[i][j][0] + d[i - a[j].first][k][1]) % 1000000007;
if (a[j].first == a[k].second && i - a[j].first > 0)
d[i][j][0] = (d[i][j][0] + d[i - a[j].first][k][0]) % 1000000007;
if (a[j].first != a[j].second) {
if (a[j].second == a[k].first && i - a[j].second > 0)
d[i][j][1] = (d[i][j][1] + d[i - a[j].second][k][1]) % 1000000007;
if (a[j].second == a[k].second && i - a[j].second > 0)
d[i][j][1] = (d[i][j][1] + d[i - a[j].second][k][0]) % 1000000007;
}
}
}
}
unsigned long long ans = 0;
for (int i = 0; i < n; ++i)
ans = ((ans + d[l][i][1]) % 1000000007 + d[l][i][0]) % 1000000007;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[3505][305];
int a[305], b[305];
const int mod = 1e9 + 7;
int main() {
int n, l;
cin >> n >> l;
for (int 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 (int i = 1; i <= l; i++) {
for (int j = 0; j < n * 2; j++) {
if (dp[i][j] == 0) continue;
for (int k = 0; k < 2 * n; k++) {
if (k % n != j % n && a[k] == b[j]) {
dp[i + a[k]][k] = (dp[i + a[k]][k] + dp[i][j]) % mod;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n * 2; i++) {
ans = (ans + dp[l][i]) % mod;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[3001][101][2];
int dim[2][100];
int n;
int f(int L, int last, int ori) {
if (L == 0) return 1;
int &ret = t[L][last][ori];
if (ret != -1) return ret;
ret = 0;
for (int i = 0; i < n; ++i)
if (i != last) {
if (dim[0][i] == dim[ori][last] && dim[0][i] <= L)
ret = (ret + f(L - dim[0][i], i, 1)) % 1000000007;
if (dim[1][i] != dim[0][i] && dim[1][i] == dim[ori][last] &&
dim[1][i] <= L)
ret = (ret + f(L - dim[1][i], i, 0)) % 1000000007;
}
return ret;
}
int main() {
memset(t, -1, sizeof(t));
int L, res = 0;
cin >> n >> L;
for (int i = 0; i < n; ++i) cin >> dim[0][i] >> dim[1][i];
for (int i = 0; i < n; ++i) {
if (dim[0][i] <= L) res = (res + f(L - dim[0][i], i, 1)) % 1000000007;
if (dim[1][i] != dim[0][i] && dim[1][i] <= L)
res = (res + f(L - dim[1][i], i, 0)) % 1000000007;
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[10005], b[10005], dp[3005][105][2];
inline int Val(int x, int y) {
if (!y) return a[x];
return b[x];
}
int main() {
int i, j, k, tip, l;
cin.sync_with_stdio(0);
cin >> n >> l;
for (i = 1; i <= n; ++i) cin >> a[i] >> b[i];
dp[0][0][0] = 1;
for (i = 0; i < l; ++i)
for (j = 0; j <= n; ++j)
for (k = 0; k < 2; ++k) {
if (!dp[i][j][k]) continue;
for (tip = 1; tip <= n; ++tip)
if (tip != j) {
if (i + a[tip] <= l && (a[tip] == Val(j, 1 - k) || !j)) {
dp[i + a[tip]][tip][0] += dp[i][j][k];
if (dp[i + a[tip]][tip][0] >= 1000000007)
dp[i + a[tip]][tip][0] -= 1000000007;
}
if (i + b[tip] <= l && (b[tip] == Val(j, 1 - k) || !j) &&
a[tip] != b[tip]) {
dp[i + b[tip]][tip][1] += dp[i][j][k];
if (dp[i + b[tip]][tip][1] >= 1000000007)
dp[i + b[tip]][tip][1] -= 1000000007;
}
}
}
int sol = 0;
for (i = 1; i <= n; ++i)
for (j = 0; j < 2; ++j) {
sol += dp[l][i][j];
if (sol >= 1000000007) sol -= 1000000007;
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, a[101], b[101], res = 0, F[3003][101][2];
scanf("%d%d", &n, &l);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
for (int i = 1; i <= l; i++)
for (int j = 1; j <= n; j++) {
if (a[j] == i)
F[i][j][0] = 1;
else if (a[j] < i) {
F[i][j][0] = 0;
for (int k = 1; k <= n; k++)
if (k != j) {
if (b[k] == a[j])
F[i][j][0] = (F[i][j][0] + F[i - a[j]][k][0]) % 1000000007;
if (a[k] != b[k] && a[k] == a[j])
F[i][j][0] = (F[i][j][0] + F[i - a[j]][k][1]) % 1000000007;
}
}
if (a[j] == b[j]) {
F[i][j][1] = 0;
continue;
}
if (b[j] == i)
F[i][j][1] = 1;
else if (b[j] <= i) {
F[i][j][1] = 0;
for (int k = 1; k <= n; k++)
if (k != j) {
if (b[k] == b[j])
F[i][j][1] = (F[i][j][1] + F[i - b[j]][k][0]) % 1000000007;
if (a[k] != b[k] && a[k] == b[j])
F[i][j][1] = (F[i][j][1] + F[i - b[j]][k][1]) % 1000000007;
}
}
}
for (int i = 1; i <= n; i++)
res = ((res + F[l][i][0]) % 1000000007 + F[l][i][1]) % 1000000007;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 109, L = 3009, mod = 1e9 + 7;
int dp[L][N][N];
int n, l;
struct node {
int x, y;
void read() { scanf("%d%d", &x, &y); };
} a[N];
int dfs(int p, int fa, int w) {
if (p > l) return 0;
int &d = dp[p][fa][w];
if (d + 1) return d;
if (p == l) return d = 1;
d = 0;
for (int i = 1; i <= n; i++)
if (i != fa) {
if (a[i].x == w) d = (d + dfs(p + a[i].x, i, a[i].y)) % mod;
if (a[i].x == a[i].y) continue;
if (a[i].y == w) d = (d + dfs(p + a[i].y, i, a[i].x)) % mod;
}
return d;
}
int main() {
cin >> n >> l;
for (int i = 1; i <= n; i++) a[i].read();
int ans = 0;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= 100; i++) {
ans = (ans + dfs(0, 0, i)) % mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
vector<vector<vector<long long int>>> v =
vector<vector<vector<long long int>>>();
v.resize(n);
for (int s = 0; s < n; ++s) {
v[s].resize(2);
v[s][0].resize(l + 1);
v[s][1].resize(l + 1);
cin >> v[s][0][0] >> v[s][1][0];
}
long long int res = 0;
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
if (v[j][0][0] == i) {
v[j][0][i] = 1;
} else if (v[j][0][0] < i) {
v[j][0][i] = 0;
for (int k = 0; k < n; k++) {
if (k == j) continue;
if (v[k][0][0] == v[j][1][0]) {
v[j][0][i] += v[k][0][i - v[j][0][0]] % 1000000007;
} else if (v[k][1][0] == v[j][1][0]) {
v[j][0][i] += v[k][1][i - v[j][0][0]] % 1000000007;
}
}
}
if (v[j][1][0] != v[j][0][0]) {
if (v[j][1][0] == i) {
v[j][1][i] = 1;
} else if (v[j][1][0] < i) {
v[j][1][i] = 0;
for (int k = 0; k < n; k++) {
if (k == j) continue;
if (v[k][0][0] == v[j][0][0]) {
v[j][1][i] += v[k][0][i - v[j][1][0]] % 1000000007;
} else if (v[k][1][0] == v[j][0][0]) {
v[j][1][i] += v[k][1][i - v[j][1][0]] % 1000000007;
}
}
}
}
}
}
for (int i = 0; i < n; i++) {
res = (v[i][0][l] % 1000000007) + (v[i][1][l] % 1000000007) +
res % 1000000007;
}
cout << res % 1000000007;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long dp[2][210][3010];
int n, l, a[210], b[210];
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++) {
dp[0][i][b[i]] = 1;
if (a[i] != b[i]) dp[1][i][a[i]] = 1;
}
for (int len = 1; len < l; len++)
for (int i = 0; i < n; i++) {
if (len + b[i] <= l)
for (int j = 0; j < n; j++) {
if (i != j && b[i] == a[j]) {
dp[0][i][len + b[i]] += dp[0][j][len];
dp[0][i][len + b[i]] %= MOD;
}
if (i != j && b[i] == b[j]) {
dp[0][i][len + b[i]] += dp[1][j][len];
dp[0][i][len + b[i]] %= MOD;
}
}
if (a[i] != b[i]) {
swap(a[i], b[i]);
if (len + b[i] <= l)
for (int j = 0; j < n; j++) {
if (i != j && b[i] == a[j]) {
dp[1][i][len + b[i]] += dp[0][j][len];
dp[1][i][len + b[i]] %= MOD;
}
if (i != j && b[i] == b[j]) {
dp[1][i][len + b[i]] += dp[1][j][len];
dp[1][i][len + b[i]] %= MOD;
}
}
swap(a[i], b[i]);
}
}
long long ans = 0;
for (int i = 0; i < 210; i++) {
ans += dp[0][i][l], ans %= MOD;
ans += dp[1][i][l], ans %= MOD;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
const int mod = 1e9 + 7;
const int maxl = 3e3 + 10;
int ans;
int n, l;
int dp[maxn][maxl];
vector<int> bois[maxn], things, oof;
void in();
void solve();
void out();
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
in();
solve();
out();
}
void in() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
bois[a].push_back(i * 2);
things.push_back(b);
oof.push_back(a);
if (b != a) {
bois[b].push_back(i * 2 + 1);
things.push_back(a);
oof.push_back(b);
} else {
things.push_back(-1);
oof.push_back(-1);
}
}
}
void solve() {
for (int i = 0; i <= things.size(); i++) dp[i][0] = 1;
for (int j = 1; j <= l; j++)
for (int i = 0; i < things.size(); i++)
if (things[i] != -1)
for (auto x : bois[things[i]])
if (j - things[i] >= 0 && (i ^ 1) != x && i != x)
dp[i][j] = (dp[i][j] + dp[x][j - things[i]]) % mod;
for (int i = 0; i < things.size(); i++)
if (things[i] != -1)
if (l - oof[i] >= 0) ans = (ans + dp[i][l - oof[i]]) % mod;
}
void out() { cout << ans; }
|
#include <bits/stdc++.h>
using namespace std;
const int con = 1e5;
const long long mod = 1000000007;
int main() {
int n, l;
cin >> n >> l;
vector<vector<int> > nab(n);
for (int i = 0; i < n; i++) {
nab[i].resize(2);
cin >> nab[i][0] >> nab[i][1];
}
vector<vector<vector<int> > > dp(l + 1 + con);
for (int i = 0; i < con; i++) {
dp[i].resize(2);
for (int j = 0; j < 2; j++) {
dp[i][j].assign(n, 0);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
dp[nab[i][j ^ 1]][j][i] = 1;
if (nab[i][j] == nab[i][j ^ 1]) break;
}
}
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
for (int q = 0; q < 2; q++) {
for (int k = 0; k < n; k++) {
for (int pol = 0; pol < 2 && (pol < 1 || nab[k][1] != nab[k][0]);
pol++) {
if (nab[j][q] == nab[k][pol] && j != k) {
dp[i + nab[k][pol]][pol ^ 1][k] += dp[i][q][j];
dp[i + nab[k][pol]][pol ^ 1][k] %= mod;
}
}
}
}
}
}
long long sol = 0LL;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) sol = (sol + dp[l][j][i]) % mod;
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000000 + 7;
const long long int N = 10000000 + 6;
long long int dp[3001][101][2];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, l;
cin >> n >> l;
long long int h[n + 1], w[n + 1];
for (int i = 1; i <= n; i++) cin >> h[i] >> w[i];
for (int j = 1; j <= n; j++) {
dp[h[j]][j][0] = 1;
if (w[j] != h[j]) dp[w[j]][j][1] = 1;
}
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= n; j++) {
int llength = i - h[j];
int lwidth = h[j];
if (llength > 0) {
for (int k = 1; k <= n; k++) {
if (k == j) continue;
if (h[k] == lwidth)
dp[i][j][0] = (dp[i][j][0] + dp[llength][k][1]) % mod;
if (w[k] == lwidth)
dp[i][j][0] = (dp[i][j][0] + dp[llength][k][0]) % mod;
}
}
if (h[j] != w[j]) {
llength = i - w[j];
lwidth = w[j];
if (llength > 0) {
for (int k = 1; k <= n; k++) {
if (k == j) continue;
if (h[k] == lwidth)
dp[i][j][1] = (dp[i][j][1] + dp[llength][k][1]) % mod;
if (w[k] == lwidth)
dp[i][j][1] = (dp[i][j][1] + dp[llength][k][0]) % mod;
}
}
}
}
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
ans = (ans + dp[l][i][0]) % mod;
if (h[i] != w[i]) ans = (ans + dp[l][i][1]) % mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 0x3f3f3f3f;
const double EI =
2.71828182845904523536028747135266249775724709369995957496696762772407663035354594571382178525166427;
const double PI = 3.141592653589793238462643383279;
using namespace std;
struct s {
int a, b, id;
} z[210];
struct ss {
int a;
};
vector<int> ve[3010];
long long dp[3010][210];
int main(void) {
int n, l, i, j, k, cnt, z1, z2, si, p;
while (~scanf("%d %d", &n, &l)) {
cnt = 0;
for (i = 0; i < n; i++) {
scanf("%d %d", &z1, &z2);
z[cnt].a = z1;
z[cnt].b = z2;
z[cnt].id = i;
cnt++;
if (z1 != z2) {
z[cnt].a = z2;
z[cnt].b = z1;
z[cnt].id = i;
cnt++;
}
}
memset(dp, 0, sizeof(dp));
for (i = 1; i <= l; i++) {
for (j = 0; j < cnt; j++) {
if (i - z[j].a < 0) {
continue;
}
if (i - z[j].a == 0) {
dp[i][j] = 1;
continue;
}
for (k = 0; k < cnt; k++) {
if (z[j].id != z[k].id && z[j].a == z[k].b) {
dp[i][j] += dp[i - z[j].a][k];
dp[i][j] %= 1000000007;
}
}
}
}
long long ans = 0;
for (i = 0; i < cnt; i++) {
ans += dp[l][i];
ans %= 1000000007;
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int modulo = 1000000007;
int n, l;
int a[100], b[100];
long long int maneras[3001][100][2];
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
for (int d = 1; d <= l; d++) {
for (int t = 0; t < n; t++) {
int aa = a[t];
int bb = b[t];
if (aa == d) {
maneras[d][t][0] += 1;
maneras[d][t][0] %= modulo;
} else if (aa < d) {
for (int tt = 0; tt < n; tt++) {
if (tt != t and b[tt] == aa) {
maneras[d][t][0] += maneras[d - aa][tt][0];
maneras[d][t][0] %= modulo;
}
if (tt != t and a[tt] == a[t]) {
maneras[d][t][0] += maneras[d - aa][tt][1];
maneras[d][t][0] %= modulo;
}
}
}
if (aa != bb) {
if (bb == d) {
maneras[d][t][1] += 1;
maneras[d][t][1] %= modulo;
} else if (bb < d) {
for (int tt = 0; tt < n; tt++) {
if (tt != t and b[tt] == bb) {
maneras[d][t][1] += maneras[d - bb][tt][0];
maneras[d][t][1] %= modulo;
}
if (tt != t and a[tt] == bb) {
maneras[d][t][1] += maneras[d - bb][tt][1];
maneras[d][t][1] %= modulo;
}
}
}
}
}
}
long long int sol = 0;
for (int t = 0; t < n; t++)
for (int s = 0; s < 2; s++) sol = (sol + maneras[l][t][s]) % modulo;
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long ans[101][2][3001];
int a[100];
int b[100];
int n;
int l;
long long int DP(int i, int o, int len) {
long long int suma = 0;
if (len == 0) {
return 1;
} else if (len < 0) {
return 0;
} else if (ans[i][o][len] != -1) {
return ans[i][o][len];
} else {
for (int j = 0; j < n; j++) {
if (j == i) {
j += 1;
}
if (o == 1 and a[j] == a[i]) {
suma += DP(j, 0, len - a[j]);
}
if (o == 0 and a[j] == b[i]) {
suma += DP(j, 0, len - a[j]);
}
if (a[j] != b[j]) {
if (o == 1 and b[j] == a[i]) {
suma += DP(j, 1, len - b[j]);
}
if (o == 0 and b[j] == b[i]) {
suma += DP(j, 1, len - b[j]);
}
}
}
}
suma = suma % mod;
ans[i][o][len] = suma;
return ans[i][o][len];
}
int main() {
memset(ans, -1, sizeof(ans));
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
long long int suma = 0;
for (int i = 0; i < n; i++) {
suma = (suma + DP(i, 0, l - a[i])) % mod;
if (a[i] != b[i]) {
suma = (suma + DP(i, 1, l - b[i])) % mod;
}
}
cout << suma;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[3001][101][101], n, l, a[101], b[101];
long long recur(long long made, long long type, long long width) {
if (made == l) return 1;
if (made > l) return 0;
if (type != -1 && width != -1 && dp[made][type][width] != -1)
return dp[made][type][width];
long long ret = 0;
for (int i = 0; i < n; i++) {
if (type == i) continue;
if (a[i] != b[i]) {
if (width == -1 || width == a[i]) {
ret += recur(made + a[i], i, b[i]);
ret %= 1000000007;
}
if (width == -1 || width == b[i]) {
ret += recur(made + b[i], i, a[i]);
ret %= 1000000007;
}
} else {
if (width == -1 || width == a[i]) {
ret += recur(made + a[i], i, b[i]);
ret %= 1000000007;
}
}
}
if (type != -1 && width != -1) {
dp[made][type][width] = ret;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
memset(dp, -1, sizeof dp);
cout << recur(0, -1, -1) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n;
int L;
int a[210];
int b[210];
int dp[3005][210];
int main() {
cin >> n;
cin >> L;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
dp[a[i]][i] = 1;
if (a[i] != b[i]) {
a[n + i] = b[i];
b[n + i] = a[i];
dp[a[n + i]][n + i] = 1;
}
}
for (int i = 1; i <= L; i++) {
for (int j = 1; j <= 2 * n; j++) {
if (dp[i][j] == 0) continue;
for (int k = 1; k <= 2 * n; k++) {
if (k == j || k + n == j || k - n == j) continue;
if (a[k] != b[j]) continue;
if (i + a[k] > L) continue;
dp[i + a[k]][k] += dp[i][j];
dp[i + a[k]][k] %= mod;
}
}
}
int cnt = 0;
for (int i = 1; i <= 2 * n; i++) {
cnt += dp[L][i];
cnt %= mod;
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (1e9) + 7;
int n, l, ans;
bool used[3128][128][2];
int state[3128][128][2];
int a[128], b[128];
int recurse(int length, int last, int flag) {
if (length < 0) return 0;
if (length == 0) return 1;
if (used[length][last][flag]) return state[length][last][flag];
int ans = 0, i, expected = ((flag == 1) ? a[last] : b[last]);
for (i = 1; i <= n; i++)
if (i != last) {
if (a[i] == expected)
ans = (ans + recurse(length - a[i], i, 0)) % MOD;
else if (b[i] == expected)
ans = (ans + recurse(length - b[i], i, 1)) % MOD;
}
used[length][last][flag] = true;
state[length][last][flag] = ans;
return ans;
}
int main() {
int i;
scanf("%d %d", &n, &l);
for (i = 1; i <= n; i++) scanf("%d %d", &a[i], &b[i]);
for (i = 1; i <= n; i++) {
ans = (ans + recurse(l - a[i], i, 0)) % MOD;
if (a[i] != b[i]) ans = (ans + recurse(l - b[i], i, 1)) % MOD;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105, MOD = 1e9 + 7;
int n, l, a[N], b[N], dp[N][3200][2];
inline void upd(int &x, int y) { x = (x + y) % MOD; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> l;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
dp[i][a[i]][0]++;
if (a[i] != b[i]) {
dp[i][b[i]][1]++;
}
}
for (int i = 1; i <= l; i++) {
for (int prv = 1; prv <= n; prv++) {
for (int cur = 1; cur <= n; cur++) {
if (cur != prv) {
if (a[cur] == b[prv]) {
upd(dp[cur][i + a[cur]][0], dp[prv][i][0]);
}
if (a[cur] == a[prv]) {
upd(dp[cur][i + a[cur]][0], dp[prv][i][1]);
}
if (a[cur] != b[cur]) {
if (b[cur] == b[prv]) {
upd(dp[cur][i + b[cur]][1], dp[prv][i][0]);
}
if (b[cur] == a[prv]) {
upd(dp[cur][i + b[cur]][1], dp[prv][i][1]);
}
}
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
upd(ans, dp[i][l][0]);
upd(ans, dp[i][l][1]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
long long dp[102][3002][2];
vector<pair<int, bool> > g[100][2];
int fence[100][2];
long long solve(int reml, int p, int b) {
long long &r = dp[p][reml][b];
if (r != -1LL) return r;
if (reml == 0) return r = 1;
r = 0;
for (auto a : g[p][b]) {
if (reml >= fence[a.first][a.second])
r += solve(reml - fence[a.first][a.second], a.first, a.second);
r %= M;
}
return r % M;
}
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> fence[i][0] >> fence[i][1];
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j == i) continue;
if (fence[i][0] == fence[j][1]) g[i][0].push_back({j, 0});
if (fence[i][1] == fence[j][0]) g[i][1].push_back({j, 1});
if (fence[j][0] != fence[j][1] && fence[i][0] == fence[j][0])
g[i][0].push_back({j, 1});
if (fence[j][0] != fence[j][1] && fence[i][1] == fence[j][1])
g[i][1].push_back({j, 0});
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
if (fence[i][0] != fence[i][1]) {
if (fence[i][0] <= l) {
ans += solve(l - fence[i][0], i, 0);
}
if (fence[i][1] <= l) {
ans += solve(l - fence[i][1], i, 1);
}
} else if (fence[i][0] <= l)
ans += solve(l - fence[i][0], i, 0);
}
cout << ans % M;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, l, a[102], b[102];
long long dp[3010][102][2];
int main() {
scanf("%d %d", &n, &l);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i], &b[i]);
dp[a[i]][i][0] = 1;
if (a[i] != b[i]) dp[b[i]][i][1] = 1;
}
for (int len = 1; len <= l; len++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (len - a[i] >= 0) {
if (a[i] == b[j]) dp[len][i][0] += dp[len - a[i]][j][0];
if (a[i] == a[j]) dp[len][i][0] += dp[len - a[i]][j][1];
dp[len][i][0] %= mod;
}
if (a[i] == b[i]) continue;
if (len - b[i] >= 0) {
if (b[i] == b[j]) dp[len][i][1] += dp[len - b[i]][j][0];
if (b[i] == a[j]) dp[len][i][1] += dp[len - b[i]][j][1];
dp[len][i][1] %= mod;
}
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += dp[l][i][0] + dp[l][i][1];
ans %= mod;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int maxl = 3005;
const int M = 1000000007;
int n, l;
int a[maxn], b[maxn];
int f[maxl][maxn][2];
void solve() {
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
f[a[i]][i][0] = 1;
if (a[i] == b[i]) continue;
f[b[i]][i][1] = 1;
}
for (int i = 1; i < l; i++)
for (int j = 0; j < n; j++) {
if (f[i][j][0]) {
for (int k = 0; k < n; k++)
if (k != j) {
if (b[j] == a[k] && i + b[j] <= l) {
f[i + b[j]][k][0] += f[i][j][0];
f[i + b[j]][k][0] %= M;
}
if (a[k] == b[k]) continue;
if (b[j] == b[k] && i + b[j] <= l) {
f[i + b[j]][k][1] += f[i][j][0];
f[i + b[j]][k][1] %= M;
}
}
}
if (f[i][j][1]) {
for (int k = 0; k < n; k++)
if (k != j) {
if (a[j] == a[k] && i + a[j] <= l) {
f[i + a[j]][k][0] += f[i][j][1];
f[i + a[j]][k][0] %= M;
}
if (a[k] == b[k]) continue;
if (a[j] == b[k] && i + a[j] <= l) {
f[i + a[j]][k][1] += f[i][j][1];
f[i + a[j]][k][1] %= M;
}
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += f[l][i][0];
ans %= M;
ans += f[l][i][1];
ans %= M;
}
cout << ans << endl;
}
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
solve();
return 0;
}
|
#include <bits/stdc++.h>
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]);
int c[3001][100][2] = {0};
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;
}
printf("%d\n", s);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
int arr[101][2] = {0};
long long dp[3001][101][2] = {-1};
long long solve(int width, int remainL, int index) {
if (remainL == 0) {
return 1;
}
int x = (width == arr[index][0]) ? 0 : 1;
if (dp[remainL][index][x] != -1) return dp[remainL][index][x];
long long val = 0;
for (int i = 0; i < n; i++) {
if (index == i) continue;
if (arr[i][0] == width && remainL - arr[i][0] >= 0) {
val += solve(arr[i][1], remainL - arr[i][0], i);
}
if (arr[i][0] == arr[i][1])
;
else if (arr[i][1] == width && remainL - arr[i][1] >= 0) {
val += solve(arr[i][0], remainL - arr[i][1], i);
}
}
return dp[remainL][index][x] = val % 1000000007;
}
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1];
}
for (int i = 0; i <= l; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j][0] = dp[i][j][1] = -1;
}
}
long long val = 0;
for (int i = 0; i < n; i++) {
if (l - arr[i][1] >= 0) val += solve(arr[i][0], l - arr[i][1], i);
if (arr[i][0] != arr[i][1] && l - arr[i][0] >= 0)
val += solve(arr[i][1], l - arr[i][0], i);
}
cout << val % 1000000007;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > woods;
long long N, L, ans;
long long memo[101][101][3001];
long long solve(long long i, long long width, long long length) {
if (i == N || length > L) return 0;
if (length == L) return 1;
long long &ret = memo[i][width][length];
if (ret != -1) return ret;
ret = 0;
for (int j = 0; j < N; j++) {
if (j != i)
if (woods[j].first == width)
ret +=
(solve(j, woods[j].second, length + woods[j].first)) % 1000000007;
else if (woods[j].second == width)
ret +=
(solve(j, woods[j].first, length + woods[j].second)) % 1000000007;
}
return ret;
}
int main() {
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));
}
for (int i = 0; i < N; i++) {
ans += solve(i, woods[i].first, woods[i].second);
if (woods[i].first != woods[i].second)
ans += solve(i, woods[i].second, woods[i].first);
}
cout << ans % 1000000007 << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 205;
const int MOD = 1000000007;
int dp[N][3105], a[N], b[N], t[N];
int main() {
int n, l, 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[i][a[i]] = 1;
}
for (i = 0; i <= l; i++) {
for (j = 1; j <= n; j++) {
int v = dp[j][i];
if (!v) continue;
for (k = 1; k <= n; k++) {
if (t[k] == t[j]) continue;
if (a[k] == b[j]) dp[k][i + a[k]] = (dp[k][i + a[k]] + v) % MOD;
}
}
}
int r = 0;
for (i = 1; i <= n; i++) r = (r + dp[i][l]) % MOD;
printf("%d\n", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int L(int i) { return i << 1; }
inline int R(int i) { return (i << 1) | 1; }
inline int B(int i) { return 1 << i; }
inline int low_bit(int x) { return x & (-x); }
int a[4010], b[4010], l, n;
int dp[110][2][4010];
int dfs(int id, int cho, int ll) {
int ret = 0, ppp, pre;
if (id == -1)
ppp = 101;
else
ppp = id;
if (id == -1)
pre = 101;
else if (cho == 0)
pre = a[id];
else
pre = b[id];
if (ll > l) return dp[ppp][cho][ll] = 0;
if (ll == l) return dp[ppp][cho][ll] = 1;
if (dp[ppp][cho][ll] >= 0) return dp[ppp][cho][ll];
for (int i = 0; i < n; i++)
if (i != id) {
if (id == -1) {
ret = (ret + dfs(i, 1, ll + a[i])) % 1000000007;
if (a[i] == b[i]) continue;
ret = (ret + dfs(i, 0, ll + b[i])) % 1000000007;
continue;
}
if (a[i] == pre) {
ret = (ret + dfs(i, 1, ll + a[i])) % 1000000007;
} else if (b[i] == pre) {
ret = (ret + dfs(i, 0, ll + b[i])) % 1000000007;
}
}
return dp[ppp][cho][ll] = ret;
}
int main() {
while (scanf("%d%d", &n, &l) != EOF) {
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
printf("%d\n", dfs(-1, 0, 0));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100], b[100];
int res[100][3001][101] = {0};
bool us[100][3001][101] = {0};
const int mod = 1000000007;
int work(int ll, int pr = -1, int lpred = -1) {
if (ll < 0) return 0;
if (ll == 0) return 1;
if (pr != -1 && us[pr][ll][lpred] != 0) return res[pr][ll][lpred];
int r = 0;
for (int i = 0; i < n; i++)
if (i != pr) {
if ((lpred == -1) || (a[i] == lpred))
r = (r + work(ll - a[i], i, b[i])) % mod;
if ((a[i] != b[i]) && ((lpred == -1) || (b[i] == lpred)))
r = (r + work(ll - b[i], i, a[i])) % mod;
}
if (pr != -1) {
res[pr][ll][lpred] = r;
us[pr][ll][lpred] = 1;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
int l;
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
cout << work(l);
}
|
#include <bits/stdc++.h>
using namespace std;
class square {
public:
int a, b;
square(int _a = 0, int _b = 0) {
a = _a;
b = _b;
}
};
bool d[201][201];
int a[3001][201];
vector<square> v1;
int use[201];
int main() {
int n, q, h, f;
scanf("%d%d", &n, &q);
for (int gh = 0, i = 0; i < n; i++) {
scanf("%d%d", &h, &f);
v1.push_back(square(h, f));
use[gh] = i;
if (h != f) v1.push_back(square(f, h)), use[++gh] = i;
gh++;
}
n = v1.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (use[i] != use[j])
if (v1[i].b == v1[j].a) d[i][j] = 1;
}
for (int i = 0; i < n; i++) a[v1[i].a][i] = 1;
for (int l = 1; l <= q; l++)
for (int p1 = 0; p1 < n; p1++)
for (int p2 = 0; p2 < n; p2++) {
if (l - v1[p1].a >= 0)
a[l][p1] = a[l][p1] + a[l - v1[p1].a][p2] * d[p2][p1],
a[l][p1] %= 1000000007;
}
long long int value = 0;
for (int p1 = 0; p1 < n; p1++) value += a[q][p1], value %= 1000000007;
printf("%d\n", value);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.