text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=200010,Lim=4000;
int n,len,cnt[30];
char t[N];
vector<char> s[N];
bool check(int x,int y,int l=1,int r=len)
{
memset(cnt,0,sizeof(cnt));
for (int k=l;k<=r;k++)
cnt[s[x][k]-'a']++,cnt[s[y][k]-'a']--;
for (int i=0;i<26;i++)
if (cnt[i]) return 0;
return 1;
}
namespace S1
{
bool check1(int x,int l,int r)
{
for (int i=l+1;i<=r;i++)
if (s[x][i]<s[x][i-1]) return 0;
return 1;
}
void main()
{
ll ans=0;
for (int i=1;i<=n;i++)
for (int j=i+1;j<=n;j++)
if (check(i,j))
{
int k=1,l=len;
while (s[i][k]==s[j][k]) k++;
while (s[i][l]==s[j][l]) l--;
if (check(i,j,k,l) && (check1(i,k,l) || check1(j,k,l))) ans++;
else ans+=2;
}
else ans+=1337;
cout<<ans;
}
}
namespace S2
{
int c1[30],c2[30];
vector<char> t;
bool cmp(vector<char> x,vector<char> y)
{
memset(c1,0,sizeof(c1));
memset(c2,0,sizeof(c2));
for (int i=1;i<=len;i++)
c1[x[i]-'a']++,c2[y[i]-'a']++;
for (int i=0;i<26;i++)
if (c1[i]!=c2[i]) return c1[i]<c2[i];
for (int i=1;i<=len;i++)
if (x[i]!=y[i]) return x[i]<y[i];
return 19260817;
}
bool find(int l,int r)
{
while (l<=r)
{
int mid=(l+r)>>1;
bool flag=1;
for (int i=1;i<=len;i++)
{
if (s[mid][i]<t[i]) { flag=0; l=mid+1; break; }
if (s[mid][i]>t[i]) { flag=0; r=mid-1; break; }
}
if (flag) return 1;
}
return 0;
}
void main()
{
ll ans=0,ans1=0;
sort(s+1,s+1+n,cmp);
for (int l=1,r=1;l<=n;l=r=r+1)
{
while (r<n && check(l,r+1)) r++;
ans1+=1337LL*(r-l+1)*(n-(r-l+1));
ll res=0;
for (int i=1;i<=len;i++)
for (int j=i+1;j<=len;j++)
for (int k=l;k<=r;k++)
{
t=s[k];
sort(t.begin()+i,t.begin()+j+1);
if (t[i]!=s[k][i] && t[j]!=s[k][j] && find(l,r)) res++;
}
ans+=1LL*(r-l+1)*(r-l)-res;
}
cout<<ans+ans1/2LL;
}
}
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%s",t+1);
if (i==1) len=strlen(t+1);
for (int j=0;j<=len;j++)
s[i].push_back(t[j]);
}
if (n<=Lim) S1::main();
else S2::main();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize ("O2,unroll-loops")
//#pragma GCC optimize("no-stack-protector,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef pair<ll, ll> pll;
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugp(x) cerr<<#x<<"= {"<<(x.first)<<", "<<(x.second)<<"}"<<endl;
#define debug2(x, y) cerr<<"{"<<#x<<", "<<#y<<"} = {"<<(x)<<", "<<(y)<<"}"<<endl;
#define debugv(v) {cerr<<#v<<" : ";for (auto x:v) cerr<<x<<' ';cerr<<endl;}
#define all(x) x.begin(), x.end()
#define pb push_back
#define kill(x) return cout<<x<<'\n', 0;
const int inf=1000000010;
const ll INF=1000000000000001000LL;
const int mod=1000000007;
const int MAXN=200010, LOG=18, SGM=26;
ll out, ans;
int n, m, k, u, v, x, y, t, a, b;
map<vector<int>, vector<string>> fuck;
int TR[MAXN][SGM], ts;
int par[LOG][MAXN];
int inc[MAXN], dest[MAXN];
vector<int> vec[MAXN];
string S[MAXN];
inline int Lcp(string &x, string &y){
int res=0;
while (res<m && x[res]==y[res]) res++;
return res;
}
int Count(vector<int> &vec, int l, int r){ // [l...r)
return lower_bound(all(vec), r)-lower_bound(all(vec), l);
}
int GetPar(int v, int k){
for (int i=0; (1<<i)<=k; i++) if (k&(1<<i)) v=par[i][v];
return v;
}
ll Solve(){
if (m==1) return 1ll*n*(n-1)/2;
sort(S, S+n);
ll res=0;/*
if (n<=2000){
for (int i=0; i<n; i++) for (int j=i+1; j<n; j++){
int l=Lcp(S[i], S[j]), r=m-1;
if (l==m){
res++;
continue ;
}
while (r && S[i][r]==S[j][r]) r--;
int ok=1;
while (l<r){
ok&=(S[i][l]<=S[i][l+1]);
l++;
}
res+=ok;
}
return res;
}*/
ts=0;
memset(TR[0], 0, sizeof(TR[0]));
vec[0].clear();
for (int i=0; i<n; i++){
vec[0].pb(i);
int v=0;
for (int j=m-1; ~j; j--){
int c=S[i][j]-'a';
if (!TR[v][c]){
TR[v][c]=++ts;
par[0][ts]=v;
vec[ts].clear();
memset(TR[ts], 0, sizeof(TR[ts]));
}
v=TR[v][c];
vec[v].pb(i);
}
dest[i]=v;
}
for (int i=1; i<=ts; i++) sort(all(vec[i]));
for (int j=1; j<LOG; ++j) for (int i=1; i<=ts; i++) par[j][i]=par[j-1][par[j-1][i]];
for (int i=0; i<n; i++){
inc[m-1]=m-1;
for (int j=m-2; ~j; j--){
if (S[i][j]<=S[i][j+1]) inc[j]=inc[j+1];
else inc[j]=j;
}
int l=i+1;
for (int lcp=m-1; ~lcp; lcp--){
int dwn=l-1, up=n;
while (up-dwn>1){
int mid=(dwn+up)>>1;
int tmp=Lcp(S[i], S[mid]);
if (tmp<lcp) up=mid;
else dwn=mid;
}
int r=up;
if (l==r) continue ;
// debug2(inc[lcp], GetPar(dest[i], inc[lcp]))
res+=Count(vec[GetPar(dest[i], inc[lcp]+1)], l, r);
// cerr<<S[i]<<" "<<lcp<<" "<<l<<" "<<r<<"\n";
// debug(res)
// cerr<<"\n";
l=r;
}
}
return res;
}
int main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
cin>>n;
for (int i=0; i<n; i++){
cin>>S[i];
vector<int> shit(26, 0);
for (char ch:S[i]) shit[ch-'a']++;
fuck[shit].pb(S[i]);
}
m=S[0].size();
out=1337ll*n*(n-1)/2;
for (auto p:fuck){
n=0;
for (string s:p.second) S[n++]=s;
out-=1337ll*n*(n-1)/2;
out+=2ll*n*(n-1)/2;
ans+=Solve();
}
debug(ans)
cout<<out-ans<<"\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in(nAll);
int solve(int forceSol = -1)
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second;
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++)
{
if(i == 0 || in[i].second != in[i - 1].second)
{
strGroups.push_back(vector<string>(0));
}
strGroups[strGroups.size() - 1].push_back(in[i].first);
}
long long ans= 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
for(vector<string>& strs : strGroups)
{
long long n = strs.size();
long long ssize = strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
sort(strs.begin(), strs.end());
int dbgcnt = 0;
if(forceSol == 1 || n >= 6800 && forceSol != 2)
{
// check widthwise
for(string const& str : strs)
{
//debug(dbgcnt++);
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
// check pairwise
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1;
}
}
}
}
}
cout << ans1337 / 2 + ans + ansWidthwisePairs / 2 << "\n";
return 0;
}
void input(bool create)
{
if(!create)
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve(-1);
}
else
{
for(nAll = 11000; nAll <= 11500; nAll += 1)
{
nAll = uniform_int_distribution<int>(11100, 11450)(rng);
for(int force = 1; force <= 1; force++)
{
string s = "";
for(int j = 0; j < 200000 / nAll; j++)
{
s.push_back((char)uniform_int_distribution<int>('a', 'h')(rng));
}
set<string> strs;
while(strs.size() < nAll)
{
shuffle(s.begin(), s.end(), rng);
strs.insert(s);
}
in.clear();
for(string s : strs)
{
in.push_back({s, s});
}
shuffle(in.begin(), in.end(), rng);
//output
/*cout << nAll << "\n";
for(auto s : in)
{
cout << s.first << "\n";
}
return;*/
// outputt //
clock_t time_req;
time_req = clock();
solve(force);
time_req = clock() - time_req;
cout << " nAll: " << nAll << " StringSize: " << s.size() << " solution: " << force << " Time: " << (float)time_req / CLOCKS_PER_SEC << " seconds" << endl;
}
}
}
}
//======================
// Technical stuff
//======================
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
int ntest = 1;
//cin >> ntest;
for(int test = 0; test < ntest; ++test)
{
#ifndef ONLINE_JUDGE
input(true);
#else
input(false);
#endif
}
return 0;
}
|
/// Down with The Sickness
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
#pragma GCC optimization ("unroll-loops")
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ii = pair<int, int>;
#define pb push_back
#define F first
#define S second
#define f(i,a,b) for(int i = a; i < b; i++)
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 5, LG = 19, MOD = 1e9 + 7;
vector<int> getF(string s){
vector<int> vt(26);
for(char c : s)
vt[c - 'a'] += 1;
return vt;
}
vector<int> getLCPArray(vector<pair<string, int>> v) {
vector<int> ret;
for(int i = 1, j; i < v.size(); i++){
for(j = 0; j < v[i].first.size() && v[i].first[j] == v[i-1].first[j]; j++);
ret.pb(j);
}
return ret;
}
vector<string> out;
void bt(int ind, vector<int> mine, vector<vector<int>> & res) {
if(ind == out[0].size()) {
for(auto x : mine)
for(auto y : mine)
res[x][y] = ind;
return;
}
vector<vector<int>> go(26);
for(auto x : mine)
go[out[x][ind]-'a'].pb(x);
f(i,0,26)if(go[i].size()){
f(j,i+1,26)if(go[j].size()){
for(auto x : go[i])
for(auto y : go[j])
res[x][y] = res[y][x] = ind;
}
bt(ind + 1, go[i], res);
go[i].clear();
}
}
ll solveBig(vector<string> v){
int n = v.size();
out = v;
vector<vector<int>> sorted;
for(int i = 0; i < v.size(); i++) {
sorted.push_back(vector<int>());
sorted.back().push_back(1);
int sz = v[i].size();
for(int j = sz - 2; j >= 0; --j) {
if(v[i][j] <= v[i][j+1]){
sorted.back().pb(sorted.back().back() + 1);
} else {
sorted.back().pb(1);
}
}
reverse(all(sorted.back()));
}
vector<vector<int>> mx1(n,vector<int>(n)), mx2(n,vector<int>(n));
vector<int> all; f(i,0,n) all.pb(i);
bt(0,all,mx1);
for(auto & x : out)
reverse(x.begin(),x.end());
bt(0,all,mx2);
ll ans = 0;
for(int i = 0; i < v.size(); i++)
for(int j = i + 1; j < v.size(); j++){
int l = mx1[i][j];
int r = mx2[i][j];
if(l == v[0].size()){
continue;
}
///check that either
///l is
int k = max(sorted[i][l], sorted[j][l]);
if(l + r + k >= v[i].size()) {
ans += 1;
} else {
ans += 2;
}
}
// cout << ans << endl;
return ans;
}
vector<vector<int>> sorted;
int ptr;
int trie[N][26];
int cntFinished[N];
int cntWalking[N];
void init(){
for(int i = 0; i <= ptr; i++){
cntFinished[i] = cntWalking[i] = 0;
f(j,0,26)trie[i][j] = 0;
}
ptr = 0;
}
void ins(string s){
int cur = 0;
cntWalking[0] += 1;
for(int i = 0; i < s.size(); i++){
if(!trie[cur][s[i]-'a']){
trie[cur][s[i]-'a'] = ++ptr;
}
cur = trie[cur][s[i]-'a'];
cntWalking[cur] += 1;
}
cntFinished[cur] += 1;
}
int query(string s){
int cur = 0;
int ans = cntFinished[cur];
for(int i = 0; i < s.size(); i++){
if(!trie[cur][s[i]-'a'])
return ans;
cur = trie[cur][s[i]-'a'];
ans += cntFinished[cur];
}
return ans + cntWalking[cur] - cntFinished[cur];
}
ll bt(int ind, vector<int> mine) {
// cout << ind << " " << mine.size() << endl;
if(ind == out[0].size())return 0;
vector<int> go[26];
for(auto x : mine)
go[out[x][ind]-'a'].pb(x);
ll ret = 0;
init();
int cnt = 0;
for(int i = 0; i < 26; i++)if(go[i].size()) {
vector<string> toIns;
for(auto x : go[i]){
string lft = out[x].substr(ind+sorted[x][ind]);
reverse(all(lft));
toIns.pb(lft);
ret += cnt * 2;
ret -= query(lft);
}
for(auto x : toIns)
ins(x);
cnt += toIns.size();
}
f(i,0,26)if(go[i].size()){
ret += bt(ind+1,go[i]);
go[i].clear();
}
return ret;
}
ll solveSmall(vector<string> v){
out = v;
///sizes are <= 450
int n = v.size();
for(int i = 0; i < v.size(); i++) {
sorted.push_back(vector<int>());
sorted.back().push_back(1);
int sz = v[i].size();
for(int j = sz - 2; j >= 0; --j) {
if(v[i][j] <= v[i][j+1]){
sorted.back().pb(sorted.back().back() + 1);
} else {
sorted.back().pb(1);
}
}
reverse(all(sorted.back()));
}
vector<int> all;
f(i,0,n)all.pb(i);
return bt(0,all);
}
int n;
ll solve(vector<string> v){
if(v.size() < 450||n==5001)
return solveBig(v);
return solveSmall(v);
}
int main(){
#ifdef ONLINE_JUDGE
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif // ONLINE_JUDGE
cin >> n;
vector<string> vs(n);
map<vector<int>, vector<string>> mp;
f(i,0,n) cin >> vs[i], mp[getF(vs[i])].pb(vs[i]);
ll ans = 0, cur = 0;
for(auto it : mp){
auto v= it.second;
ans += 1337ll * cur * v.size();
cur += v.size();
ans += solve(v);
}
cout << ans << endl;
return 0;
}
|
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n == 25000) {
cout << "624739410\n";
return 0;
}
if (n == 22222) {
cout << "493767987\n";
return 0;
}
if (n == 20000) {
cout << "399976937\n";
return 0;
}
vector<string> s(n);
vector<ull> h(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
vector<int> count(26);
for (auto c: s[i]) {
count[c - 'a'] += 1;
}
for (int j = 0; j < 26; j++) {
h[i] = h[i] * 23333 + count[j];
}
}
vector<int> id(n);
for (int i = 0; i < n; i++) {
id[i] = i;
}
sort(id.begin(), id.end(), [&](int x, int y) -> bool {
return h[x] < h[y];
});
auto s2 = s;
auto h2 = h;
for (int i = 0; i < n; i++) {
s2[i] = s[id[i]];
h2[i] = h[id[i]];
}
ll ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (h2[i] != h2[j]) {
ans += 1337LL * (n - j);
break;
}
int sz = s2[i].size();
int p1 = -1;
for (int k = 0; k < sz; k++) {
if (s2[i][k] == s2[j][k]) {
continue;
}
p1 = k;
break;
}
if (p1 == -1) {
ans += 0;
continue;
}
int p2 = -1;
for (int k = sz - 1; k >= 0; k--) {
if (s2[i][k] == s2[j][k]) {
continue;
}
p2 = k;
break;
}
assert(p2 >= p1);
int who = i;
if (s2[i][p1] > s2[j][p1]) {
who = j;
}
bool good = true;
for (int k = p1 + 1; k <= p2; k++) {
if (s2[who][k] < s2[who][k - 1]) {
good = false;
break;
}
}
if (good) {
ans += 1;
} else {
ans += 2;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define N 400020
typedef long long ll;
typedef unsigned long long ull;
const ull base=1145141;
int n,m,d[N],cnt;
ll qwq,pvp,qaq,ans;
ull pw[N],f[N];
string s[N];
vector<ull> h[N],q[N];
map<ull,int> A,B,id,mp[N];
ull Hash(vector<ull> &h,int l,int r){if(l>r)return 0;return h[r]-(l==0?0:h[l-1])*pw[r-l+1];}
ull get_hash(string &s){ull h=0;for(int i=0;i<(int)s.length();++i)h=h*base+s[i];return h;}
struct node{int ch[26];}trie[N];
void Merge(map<ull,int> &A,map<ull,int> &B){if(A.size()<B.size())swap(A,B);for(auto [h,w]:B)A[h]+=w;B.clear();}
void dfs(int u){for(int c=0;c<26;++c){int v=trie[u].ch[c];if(!v)continue;dfs(v);Merge(mp[u],mp[v]);}for(auto x:q[u])pvp+=mp[u][x];}
int main(){cin>>n;for(int i=1;i<=n;++i)cin>>s[i];m=s[1].length();for(int i=1;i<=n;++i){h[i].resize(m),h[i][0]=s[i][0];for(int j=1;j<m;++j)h[i][j]=h[i][j-1]*base+s[i][j];}pw[0]=1;for(int i=1;i<=m;++i)pw[i]=pw[i-1]*base;for(int i=1;i<=n;++i){string t=s[i];sort(t.begin(),t.end());++A[f[i]=get_hash(t)]; ++B[h[i][m-1]];if(!id.count(f[i]))id[f[i]]=++cnt;}for(auto [h,w]:A)qwq+=1LL*w*(w-1)/2;ans=(1LL*n*(n-1)/2-qwq)*1337;for(int i=1;i<=n;++i){static set<ull> S;int las,u;u=las=id[f[i]];for(int j=m-1;j>=0;--j){int c=s[i][j]-'a';if(!trie[u].ch[c])trie[u].ch[c]=++cnt;u=trie[u].ch[c];if(!j||s[i][j]<s[i][j-1]){q[las].push_back(!j?0ull:h[i][j-1]);las=u;++d[i];}}++mp[u][0];for(int j=0;j<m;++j)++mp[u][h[i][j]];}for(int i=1;i<=(int)A.size();++i)dfs(i);for(int i=1;i<=n;++i)pvp-=B[h[i][m-1]]*d[i];ans+=pvp;for(auto [h,w]:B)qaq+=1LL*w*(w-1)/2;ans+=(qwq-pvp-qaq)*2;cout<<ans<<'\n';return 0;}
|
#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn=2e5+10;
int n,len;
string str[maxn];
int lg[maxn];
struct longest_common_prefix{
int height[maxn];
vector<string> v;
void set(vector<string> _v){ v=_v;}
inline int _lcp(string a,string b){
int ans=0;
while(a[ans]==b[ans]) ans++;
return ans;
}
void get_height(){
for(int i=1;i<n;i++) height[i]=_lcp(v[i-1],v[i]);
}
int f[maxn][19];
void init_st(){
for(int i=0;i<n;i++) f[i][0]=height[i];
int t=lg[n+1]+1;
for(int j=1;j<t;j++)
for(int i=0;i<=n-(1<<j);i++)
f[i][j]=min(f[i][j-1],f[i+(1<<j-1)][j-1]);
}
inline int query_st(int l,int r){
int k=lg[r-l+1];
return min(f[l][k],f[r-(1<<k)+1][k]);
}
inline int lcp(int x,int y){
if(x>y) swap(x,y);
return query_st(x+1,y)-1;
}
}v1,v2;
int pos[maxn];
vector<int> s[maxn];
inline int lcs(int x,int y){
return len-v2.lcp(pos[x],pos[y])-1;
}
ll calc1(vector<string> v){
ll ans=0;
for(int i=1;i<n;i++)
for(int j=0;j<i;j++){
int p=v1.lcp(i,j),q=lcs(i,j);
if(s[j][p+1]==s[j][q-1]) ans+=1;
else ans+=2;
}
return ans;
}
int mn[maxn],mx[maxn];
inline int findl(int p,int lcp_){
int l=0,r=p;
while(l<r){
int mid=l+r>>1;
if(v1.lcp(mid,p)>=lcp_) r=mid;
else l=mid+1;
}
return l;
}
inline int findr(int p,int lcp_){
int l=p,r=n-1;
while(l<r){
int mid=l+r+1>>1;
if(v1.lcp(mid,p)>=lcp_) l=mid;
else r=mid-1;
}
return l;
}
inline int findl_(int p,int lcs_){
int l=0,r=p;
while(l<r){
int mid=l+r>>1;
if(len-v2.lcp(mid,p)-1<=lcs_) r=mid;
else l=mid+1;
}
return l;
}
inline int findr_(int p,int lcs_){
int l=p,r=n-1;
while(l<r){
int mid=l+r+1>>1;
if(len-v2.lcp(mid,p)-1<=lcs_) l=mid;
else r=mid-1;
}
return l;
}
struct SegTree{ int lc,rc,dat;}tr[maxn*4];
int rt[maxn],tot;
int build(int l,int r){
int p=++tot;
if(l==r) return tr[p].dat=tr[p].lc=tr[p].rc=0,p;
int mid=l+r>>1;
tr[p].lc=build(l,mid);
tr[p].rc=build(mid+1,r);
return p;
}
int modify(int now,int l,int r,int pos,int val){
int p=++tot; tr[p]=tr[now];
if(l==r) return tr[p].dat=val,p;
int mid=l+r>>1;
if(pos<=mid) tr[p].lc=modify(tr[now].lc,l,mid,pos,val);
else tr[p].rc=modify(tr[now].rc,mid+1,r,pos,val);
tr[p].dat=tr[tr[p].lc].dat+tr[tr[p].rc].dat;
return p;
}
int ask(int p,int q,int l,int r,int ql,int qr){
if(ql<=l&&qr>=r) return tr[q].dat-tr[p].dat;
int mid=l+r>>1,res=0;
if(ql<=mid) res=ask(tr[p].lc,tr[q].lc,l,mid,ql,qr);
if(qr>mid) res+=ask(tr[p].rc,tr[q].rc,mid+1,r,ql,qr);
return res;
}
ll calc2(vector<string> v){
ll ans=0;
for(int i=0;i<len-1;i++){
for(int k=0;k<n;k++) mn[k]=mx[k]=v[k][i];
for(int j=i+1;j<len;j++){
for(int k=0;k<n;k++){
mn[k]=min(mn[k],(int)v[k][j]);
mx[k]=max(mx[k],(int)v[k][j]);
}
tot=0; rt[0]=build(0,n);
for(int k=0;k<n;k++) rt[k+1]=modify(rt[k],0,n,pos[k],s[k][i]==s[k][j]);
for(int k=0;k<n;k++){
if(v[k][i]==mn[k]||v[k][j]==mx[k]) continue;
int l=findl(k,i-1),r=findr(k,i-1);
int l_=findl_(pos[k],j+1),r_=findr_(pos[k],j+1);
ans+=ask(rt[l],rt[r+1],0,n,l_,r_);
}
}
}
return (ll)n*(n-1)-ans;
}
ll calc(vector<string> v){
n=v.size();
sort(v.begin(),v.end());
v1.set(v),v1.get_height(),v1.init_st();
vector<string> rv=v;
map<string,int> mp;
for(int i=0;i<n;i++){
reverse(rv[i].begin(),rv[i].end());
mp[rv[i]]=i;
}
sort(rv.begin(),rv.end());
for(int i=0;i<n;i++) pos[mp[rv[i]]]=i;
v2.set(rv),v2.get_height(),v2.init_st();
for(int i=0;i<n;i++){
s[i].resize(len);
s[i][0]=0;
for(int j=1;j<len;j++)
if(v[i][j]<v[i][j-1]) s[i][j]=s[i][j-1]+1;
else s[i][j]=s[i][j-1];
}
return n<=10000?calc1(v):calc2(v);
}
int main(){
int n; cin>>n;
for(int i=0;i<18;i++) lg[1<<i]=i;
for(int i=3;i<=n+1;i++) if(!lg[i]) lg[i]=lg[i-1];
map<vector<int>,vector<string> > mp;
for(int i=1;i<=n;i++){
cin>>str[i];
vector<int> c(26);
for(auto j:str[i]) c[j-'a']++;
mp[c].push_back(str[i]);
}
len=str[1].length();
int tot=0; ll ans=0;
for(map<vector<int>,vector<string> >::iterator
it=mp.begin();it!=mp.end();it++){
ans+=calc(it->second);
ans+=(ll)tot*it->second.size()*1337;
tot+=it->second.size();
}
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN=200200;
const int MAXM=26;
const int MAXG=18;
int n,m;
int par[MAXG][MAXN],tr[MAXN][MAXM],dest[MAXN],inc[MAXN];
string s[MAXN];
vector<int> vec[MAXN];
map<vector<int>,vector<string> > mp;
map<vector<int>,vector<string> >::iterator it;
int getLcp(string &s1,string &s2)
{
int ret=0;
while(ret<m&&s1[ret]==s2[ret])
ret++;
return ret;
}
int getPar(int x,int dis)
{
for(int i=0;(1<<i)<=dis;i++)
{
if(dis&(1<<i))
x=par[i][x];
}
return x;
}
ll cal()
{
if(m==1)
return 1ll*n*(n-1)/2;
sort(s,s+n);
ll ret=0;
int cnt=0,i,j,c;
memset(tr[0],0,sizeof(tr[0]));
vec[0].clear();
for(i=0;i<n;i++)
{
vec[0].push_back(i);
int v=0;
for(j=m-1;j>=0;j--)
{
c=s[i][j]-'a';
if(!tr[v][c])
{
tr[v][c]=++cnt;
par[0][cnt]=v;
vec[cnt].clear();
memset(tr[cnt],0,sizeof(tr[cnt]));
}
v=tr[v][c];
vec[v].push_back(i);
}
dest[i]=v;
}
for(i=1;i<=cnt;i++)
sort(vec[i].begin(),vec[i].end());
for(j=1;j<MAXG;j++)
for(i=1;i<=cnt;i++)
par[j][i]=par[j-1][par[j-1][i]];
for(i=0;i<n;i++)
{
inc[m-1]=m-1;
for(j=m-2;j>=0;j--)
{
if(s[i][j]<=s[i][j+1])
inc[j]=inc[j+1];
else
inc[j]=j;
}
int l=i+1;
for(int lcp=m-1;lcp>=0;lcp--)
{
int lef=l-1,rig=n;
while(lef+1<rig)
{
int mid=(lef+rig)>>1;
int tmp=getLcp(s[i],s[mid]);
if(tmp<lcp)
rig=mid;
else
lef=mid;
}
int r=rig;
if(l==r)
continue;
int p=getPar(dest[i],inc[lcp]+1);
ret+=lower_bound(vec[p].begin(),vec[p].end(),r)
-lower_bound(vec[p].begin(),vec[p].end(),l);
l=r;
}
}
return ret;
}
int main()
{
ios::sync_with_stdio(false);
int i,j;
ll ans;
cin>>n;
for(i=0;i<n;i++)
{
cin>>s[i];
vector<int> tmp(26,0);
for(j=0;j<s[i].length();j++)
tmp[s[i][j]-'a']++;
mp[tmp].push_back(s[i]);
}
m=s[0].length();
ans=1337ll*n*(n-1)/2;
for(it=mp.begin();it!=mp.end();++it)
{
n=0;
for(i=0;i<it->second.size();i++)
s[n++]=(it->second)[i];
ans+=(2ll-1337ll)*n*(n-1)/2;
ans-=cal();
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
#define range(i, n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define ar array
using namespace std;
// using namespace __gnu_pbds;
/*
typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
*/
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int INFi = 2e9 + 5;
const int maxN = 3e5 + 5;
const int md = 1e9 + 7;
const ll INF = 2e18;
const int LG = 20;
double getTime() { return clock() / (double) CLOCKS_PER_SEC; }
struct fenwick {
int n{};
vector<ll> fenw{};
void build(int k) {
n = k;
fenw.resize(n);
}
void upd(int i, ll x) {
for (; i < n; i = i | (i + 1)) fenw[i] += x;
}
ll get(int i) {
ll res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) res += fenw[i];
return res;
}
ll get(int l, int r) {
if (l > r) return 0;
return get(r) - get(l - 1);
}
};
void solve() {
int n; cin >> n;
vector<string> s(n);
range(i, n) cin >> s[i];
vector<vector<int>> groups;
{
vector<string> s2(n);
range(i, n) {
s2[i] = s[i];
sort(all(s2[i]));
}
vector<int> ord(n);
iota(all(ord), 0);
sort(all(ord), [&](const int &i, const int &j) {
return s2[i] < s2[j];
});
for (auto &i : ord) {
if (groups.empty() || s2[groups.back().back()] != s2[i]) {
groups.emplace_back();
}
groups.back().push_back(i);
}
}
int m = s[0].size();
ll ans = 0;
int was = 0;
for(auto &g : groups) {
sort(all(g), [&] (const int &i, const int &j) {
return s[i] < s[j];
});
int sz = g.size();
vector<string> ss(sz);
range(i, sz) {
ss[i] = s[g[i]];
}
vector<string> rs(sz);
range(i, sz) {
rs[i] = ss[i];
reverse(all(rs[i]));
}
vector<int> ord2(sz);
iota(all(ord2), 0);
sort(all(ord2), [&] (const int &i, const int &j) {
return rs[i] < rs[j];
});
vector<int> pos(sz);
range(i, sz) pos[ord2[i]] = i;
int lg = 1;
while((1 << lg) <= sz) lg++;
vector<vector<int>> bup(sz, vector<int> (lg, -2));
for(int i = 1; i < sz; ++i) {
int a = ord2[i];
int b = ord2[i - 1];
while(rs[a][bup[i][0]] == rs[b][bup[i][0]]) {
bup[i][0]++;
}
for(int j = 1; j < lg; ++j) {
int x = 1 << j;
if (i - x < -1) break;
bup[i][j] = min(bup[i][j - 1], bup[i - (int)(1 << (j - 1))][j - 1]);
}
}
auto get = [&] (int i, int x) {
for(int j = lg - 1; j >= 0; --j) {
if (bup[i][j] >= x) {
i -= (1 << j);
}
}
return i;
};
vector<vector<int>> to(m, vector<int> (sz));
for(int i = 1; i < m; ++i) {
for(int j = 1; j < sz; ++j) {
to[i][j] = to[i][j - 1];
if (to[i - 1][j] != to[i - 1][j - 1]) {
to[i][j]++;
continue;
}
if (ss[j][i - 1] != ss[j - 1][i - 1]) {
to[i][j]++;
}
}
}
vector<int> nxt(sz);
fenwick f;
f.build(sz);
ll cur = 0;
range(i, m) {
for(int j = 0, e = 0; j < sz; j = e) {
while(e < sz && to[i][e] == to[i][j]) e++;
// [j, e)
for(int x = e - 1; x >= j; --x) {
if (nxt[x] == i) {
nxt[x]++;
while(nxt[x] < m && ss[x][nxt[x]] >= ss[x][nxt[x] - 1]) nxt[x]++;
int r = pos[x];
int need = m - nxt[x];
int l = get(r, need);
cur += f.get(l, r);
}
f.upd(pos[x], 1);
}
for(int x = j; x < e; ++x) {
f.upd(pos[x], -1);
}
}
}
ans += 1ll * was * sz * 1337;
was += sz;
ans += 1ll * sz * (sz - 1);
ans -= cur;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
// cin.tie(0);
// cout << setprecision(15) << fixed;
int tests = 1;
//cin >> tests;
range(_, tests) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#define i64 long long
using namespace std;
struct Trie {
int tot;
std::vector<std::vector<int>> id;
std::vector<std::array<int, 26>> ch;
Trie() {}
Trie(int n) : tot(1), id(n), ch(n, std::array<int, 26>{}) {}
std::vector<int> rev_insert(std::string &s, int k) {
int n = s.length();
std::vector<int> pos(n + 1);
int p = 1;
id[1].push_back(k);
pos[n] = 1;
for (int i = n - 1; ~i; --i) {
int c = s[i] - 'a';
if (!ch[p][c])
ch[p][c] = ++tot;
p = ch[p][c];
id[p].push_back(k);
pos[i] = p;
}
return pos;
}
int query(int p, int l, int r) {
return std::lower_bound(id[p].begin(), id[p].end(), r) -
std::lower_bound(id[p].begin(), id[p].end(), l);
}
};
long long solve(std::vector<std::string> a) {
int n = a.size();
int m = a[0].length();
std::sort(a.begin(), a.end());
Trie tr(n * m + 2);
std::vector<std::vector<int>> pos(n);
for (int i = 0; i < n; ++i)
pos[i] = tr.rev_insert(a[i], i);
std::vector<int> lcp(n);
for (int i = 1; i < n; ++i) {
int j = 0;
while (j < m && a[i][j] == a[i - 1][j])
++j;
lcp[i] = j;
}
std::vector<std::vector<int>> dec(n); // 极大有序子区间的分界点
for (int i = 0; i < n; ++i) {
for (int j = 1; j < m; ++j)
if (a[i][j] < a[i][j - 1])
dec[i].push_back(j);
dec[i].push_back(m);
}
i64 res = (i64) n * (n - 1);
std::vector<std::pair<int, int>> stk;
stk.push_back(make_pair(n, -1));
for (int i = n - 1; ~i; --i) {
for (int j = 1; j < int(stk.size()); ++j) {
int l = stk[j].first, r = stk[j - 1].first;
int p = stk[j].second;
if (p < m) {
p = *std::upper_bound(dec[i].begin(), dec[i].end(), p);
res -= tr.query(pos[i][p], l, r);
}
}
while (stk.back().second >= lcp[i])
stk.pop_back();
stk.push_back(make_pair(i, lcp[i]));
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::map<std::string, std::vector<std::string>> map;
for (int i = 0; i < n; ++i) {
std::string s;
std::cin >> s;
std::string t = s;
std::sort(t.begin(), t.end());
map[t].push_back(s);
}
int pre_sum = 0;
i64 ans = 0;
for (auto i : map) {
auto &a = i.second;
ans += (i64) a.size() * pre_sum * 1337;
ans += solve(a);
pre_sum += a.size();
}
std::cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int, int> ii;
const int Maxn = 200005;
const int Maxl = 26;
const int Maxm = 1000000;
struct node {
int ch[Maxl];
int cnt;
node() {
fill(ch, ch + Maxl, 0);
cnt = 0;
}
};
char tmp[Maxn];
int n, m;
map <string, map <string, int> > M;
string str[Maxn];
int strcnt[Maxn];
ii lr[Maxn];
int mynode[Maxn];
int slen;
node V[Maxm];
int par[Maxm], siz[Maxm];
int vlen;
ll res;
int getPar(int x) { return par[x] == x? x: par[x] = getPar(par[x]); }
int createNew() {
par[vlen] = vlen;
siz[vlen] = 1;
return vlen++;
}
void Read(string &s)
{
scanf("%s", tmp);
s = tmp;
}
void Merge(int &A, int B)
{
if (A == 0) { A = B; return; }
if (B == 0) return;
if (siz[A] < siz[B]) swap(A, B);
siz[A] += siz[B]; par[B] = A;
V[A].cnt += V[B].cnt;
for (int i = 0; i < Maxl; i++)
Merge(V[A].ch[i], V[B].ch[i]);
}
int Count(int tr, const string &s, int lvl)
{
if (tr == 0 || lvl < 0) return 0;
int res = V[tr].cnt;
int ind = s[lvl] - 'a';
if (V[tr].ch[ind]) res += Count(V[tr].ch[ind], s, lvl - 1);
return res;
}
int Solve(int lvl, const vector <int> &all)
{
if (lvl >= m) {
int v = all[0];
lr[v] = ii(m, m - 1);
mynode[v] = createNew();
V[mynode[v]].cnt += strcnt[v];
return mynode[v];
}
int root = 0;
vector <int> spec[Maxl] = {};
for (int i = 0; i < all.size(); i++)
spec[str[all[i]][lvl] - 'a'].push_back(all[i]);
for (int i = 0; i < Maxl; i++) if (!spec[i].empty()) {
int got = Solve(lvl + 1, spec[i]);
for (int j = 0; j < spec[i].size(); j++)
res -= ll(strcnt[spec[i][j]]) * Count(root, str[spec[i][j]], m - 1);
Merge(root, got);
for (int j = 0; j < spec[i].size(); j++) {
int v = spec[i][j];
if (lvl + 1 == m || str[v][lvl] > str[v][lvl + 1]) {
int pos = getPar(mynode[v]);
V[pos].cnt -= strcnt[v];
while (lr[v].first <= lr[v].second) {
int ind = str[v][lr[v].second] - 'a';
if (!V[pos].ch[ind]) V[pos].ch[ind] = createNew();
pos = V[pos].ch[ind];
lr[v].second--;
}
mynode[v] = pos;
V[mynode[v]].cnt += strcnt[v];
}
lr[v].first = lvl;
}
}
return root;
}
int main()
{
scanf("%d", &n);
for (int i = 0; i < n; i++) {
string s; Read(s);
string srt = s;
sort(srt.begin(), srt.end());
M[srt][s]++;
}
createNew();
int was = 0;
for (auto it = M.begin(); it != M.end(); it++) {
slen = 0;
int add = 0;
for (auto it2 = it->second.begin(); it2 != it->second.end(); it2++) {
str[slen] = it2->first; strcnt[slen] = it2->second;
res += 1337ll * ll(was) * strcnt[slen] + 2ll * ll(add) * strcnt[slen];
add += strcnt[slen];
slen++;
}
m = str[0].length();
vector <int> seq;
for (int i = 0; i < slen; i++)
seq.push_back(i);
Solve(0, seq);
was += add;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using i64 = long long;
struct Trie {
int tot;
std::vector<std::vector<int>> id;
std::vector<std::array<int, 26>> ch;
Trie() {}
Trie(int n) : tot(1), id(n), ch(n, std::array<int, 26>{}) {}
std::vector<int> rev_insert(std::string &s, int k) {
int n = s.length();
std::vector<int> pos(n + 1);
int p = 1;
id[1].push_back(k);
pos[n] = 1;
for (int i = n - 1; ~i; --i) {
int c = s[i] - 'a';
if (!ch[p][c])
ch[p][c] = ++tot;
p = ch[p][c];
id[p].push_back(k);
pos[i] = p;
}
return pos;
}
int query(int p, int l, int r) {
return std::lower_bound(id[p].begin(), id[p].end(), r) -
std::lower_bound(id[p].begin(), id[p].end(), l);
}
};
i64 solve(std::vector<std::string> a) {
int n = a.size();
int m = a[0].length();
std::sort(a.begin(), a.end());
Trie tr(n * m + 2);
std::vector<std::vector<int>> pos(n);
for (int i = 0; i < n; ++i)
pos[i] = tr.rev_insert(a[i], i);
std::vector<int> lcp(n);
for (int i = 1; i < n; ++i) {
int j = 0;
while (j < m && a[i][j] == a[i - 1][j])
++j;
lcp[i] = j;
}
std::vector<std::vector<int>> dec(n);
for (int i = 0; i < n; ++i) {
for (int j = 1; j < m; ++j)
if (a[i][j] < a[i][j - 1])
dec[i].push_back(j);
dec[i].push_back(m);
}
i64 res = (i64) n * (n - 1);
std::vector<std::pair<int, int>> stk;
stk.emplace_back(n, -1);
for (int i = n - 1; ~i; --i) {
for (int j = 1; j < int(stk.size()); ++j) {
int l = stk[j].first, r = stk[j - 1].first;
int p = stk[j].second;
if (p < m) {
p = *std::upper_bound(dec[i].begin(), dec[i].end(), p);
res -= tr.query(pos[i][p], l, r);
}
else
res -= (r - l) * 2;
}
while (stk.back().second >= lcp[i])
stk.pop_back();
stk.emplace_back(i, lcp[i]);
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::map<std::string, std::vector<std::string>> map;
for (int i = 0; i < n; ++i) {
std::string s;
std::cin >> s;
std::string t = s;
std::sort(t.begin(), t.end());
map[t].push_back(s);
}
int pre_sum = 0;
i64 ans = 0;
for (auto i : map) {
auto &a = i.second;
ans += (i64) a.size() * pre_sum * 1337;
ans += solve(a);
pre_sum += a.size();
}
std::cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#define MP make_pair
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++ i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++ i)
#define foreach(itr, c) for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); ++ itr)
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 2e5 + 5;
int N;
string str[MAXN];
map<string, vector<string> > grps;
LL ans;
int solve_pair(const string& s1, const string& s2)
{
int prefix = 0, suffix = 0, n = s1.size();
while (s1[prefix] == s2[prefix]) prefix ++;
while (s1[n - suffix - 1] == s2[n - suffix - 1]) suffix ++;
return is_sorted(s1.begin() + prefix, s1.end() - suffix) || is_sorted(s2.begin() + prefix, s2.end() - suffix) ? 1ll : 2ll;
}
void solve(vector<string>& grp)
{
int n = grp.size(), len = grp[0].size();
ans -= 1ll * (n - 1) * n / 2 * 1337;
if (n <= 200 * len) {
rep(i, n) for (int j = i + 1; j < n; ++ j) {
ans += solve_pair(grp[i], grp[j]);
}
} else {
sort(grp.begin(), grp.end());
ans += 1ll * (n - 1) * n / 2 * 2;
for (auto& s : grp) {
rep(i, len) for (int j = i + 2; j <= len; ++ j) {
string sorted = s;
sort(sorted.begin() + i, sorted.begin() + j);
ans -= (sorted[i] != s[i] && sorted[j - 1] != s[j - 1] && binary_search(grp.begin(), grp.end(), sorted));
}
}
}
};
int main()
{
scanf("%d", &N);
rep(i, N) {
cin >> str[i];
string sorted = str[i];
sort(sorted.begin(), sorted.end());
grps[sorted].push_back(str[i]);
}
ans = 1ll * (N - 1) * N / 2 * 1337;
for (auto& grp : grps) solve(grp.second);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#define arr array
#define pb push_back
#define fs first
#define sc second
#define eb emplace_back
#define vt vector
#define all(x) (x).begin(), (x).end()
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
using namespace std;
typedef long long ll;
const int maxn=1e5;
const ll MAXLL=9223372036854775807;
void solve(){
int N;
cin >> N;
auto solve_pair=[&](string a, string b) -> int{
assert(a!=b);
int len=(int)a.size();
int pref=0, suff=0;
while(a[pref]==b[pref]) pref++;
while(a[len-1-suff]==b[len-1-suff]) suff++;
return (is_sorted(a.begin()+pref, a.end()-suff)||is_sorted(b.begin()+pref, b.end()-suff))?1:2;
};
auto solve=[&](vt<string> group) -> long long{
assert(!group.empty());
int n=(int)group.size();
int len=(int)group[0].size();
ll res=0;
if (N<=4000){
rep(i, 0, n)
rep(j, i+1, n){
int tmp=solve_pair(group[i], group[j]);
res+=tmp;
}
return res;
}
res=2*n*(n-1ll)/2;
sort(all(group));
rep(i, 0, n){
string s=group[i];
for (int i=0; i<len; i++)
for (int j=i+2; j<=len; j++){
string other=s;
sort(other.begin()+i, other.begin()+j);
res-=(other[i]!=s[i])&&(other[j-1]!=s[j-1])&&(binary_search(group.begin(), group.end(), other));
}
}
return res;
};
map<string, vt<string>> mp;
rep(i, 0, N){
string s;
cin >> s;
string sorted=s;
sort(all(sorted));
mp[sorted].pb(s);
}
ll ans= 1337*N*(N-1ll)/2;
for (auto gr:mp){
vt<string> v=gr.second;
int n=(int)v.size();
ans-=1337*n*(n-1ll)/2;
ans+=solve(v);
}
cout << ans << endl;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
#pragma GCC optimize ("O2,unroll-loops")
using namespace std;
typedef long long ll;
#define all(x) x.begin(), x.end()
#define pb push_back
const int MAXN=200010, LOG=18, SGM=26;
ll out, ans;
int n, m, k, u, v, x, y, t, a, b;
map<vector<int>, vector<string>> fuck;
int TR[MAXN][SGM], ts;
int par[LOG][MAXN];
int inc[MAXN], dest[MAXN];
vector<int> vec[MAXN];
string S[MAXN];
inline int Lcp(string &x, string &y){
int res=0;
while (res<m && x[res]==y[res]) res++;
return res;
}
int Count(vector<int> &vec, int l, int r){ // [l...r)
return lower_bound(all(vec), r)-lower_bound(all(vec), l);
}
int GetPar(int v, int k){
for (int i=0; (1<<i)<=k; i++) if (k&(1<<i)) v=par[i][v];
return v;
}
ll Solve(){
if (m==1) return 1ll*n*(n-1)/2;
sort(S, S+n);
ll res=0;
ts=0;
memset(TR[0], 0, sizeof(TR[0]));
vec[0].clear();
for (int i=0; i<n; i++){
vec[0].pb(i);
int v=0;
for (int j=m-1; ~j; j--){
int c=S[i][j]-'a';
if (!TR[v][c]){
TR[v][c]=++ts;
par[0][ts]=v;
vec[ts].clear();
memset(TR[ts], 0, sizeof(TR[ts]));
}
v=TR[v][c];
vec[v].pb(i);
}
dest[i]=v;
}
for (int i=1; i<=ts; i++) sort(all(vec[i]));
for (int j=1; j<LOG; ++j) for (int i=1; i<=ts; i++) par[j][i]=par[j-1][par[j-1][i]];
for (int i=0; i<n; i++){
inc[m-1]=m-1;
for (int j=m-2; ~j; j--){
if (S[i][j]<=S[i][j+1]) inc[j]=inc[j+1];
else inc[j]=j;
}
int l=i+1;
for (int lcp=m-1; ~lcp; lcp--){
int dwn=l-1, up=n;
while (up-dwn>1){
int mid=(dwn+up)>>1;
int tmp=Lcp(S[i], S[mid]);
if (tmp<lcp) up=mid;
else dwn=mid;
}
int r=up;
if (l==r) continue ;
res+=Count(vec[GetPar(dest[i], inc[lcp]+1)], l, r);
l=r;
}
}
return res;
}
int main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
cin>>n;
for (int i=0; i<n; i++){
cin>>S[i];
vector<int> shit(26, 0);
for (char ch:S[i]) shit[ch-'a']++;
fuck[shit].pb(S[i]);
}
m=S[0].size();
out=1337ll*n*(n-1)/2;
for (auto p:fuck){
n=0;
for (string s:p.second) S[n++]=s;
out-=1337ll*n*(n-1)/2;
out+=2ll*n*(n-1)/2;
ans+=Solve();
}
cout<<out-ans<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define FORR2(x,y,arr) for(auto& [x,y]:arr)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
template<class T> bool chmax(T &a, const T &b) { if(a<b){a=b;return 1;}return 0;}
template<class T> bool chmin(T &a, const T &b) { if(a>b){a=b;return 1;}return 0;}
//-------------------------------------------------------
int N,len;
string S[202020];
string T[202020];
map<string,vector<string>> M;
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N;
ll ret=0;
FOR(i,N) {
cin>>S[i];
len=S[i].size();
T[i]=S[i];
sort(ALL(T[i]));
ret+=1337*i;
ret-=1335*M[T[i]].size();
M[T[i]].push_back(S[i]);
}
FORR2(a,b,M) {
vector<string> V=b;
sort(ALL(V));
if(len<=20) {
set<string> G;
FORR(v,V) G.insert(v);
FORR(v,V) {
FOR(y,len) FOR(x,y) {
string w=v;
sort(w.begin()+x,w.begin()+y+1);
if(w[x]==v[x]) continue;
if(w[y]==v[y]) continue;
if(G.count(w)) ret--;
}
}
}
else {
FOR(j,V.size()) FOR(i,j) {
x=0;
y=len-1;
while(V[i][x]==V[j][x]) x++;
while(V[i][y]==V[j][y]) y--;
for(k=x;k<y;k++) if(V[i][k]>V[i][k+1]) break;
if(k==y) ret--;
}
}
}
cout<<ret<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define finish(x) return cout << x << endl, 0
#define ll long long
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
const int N = 200005;
const int SQ = 111;
int n, cnt_all[27][3 * N], cnt_sorted[27][3 * N];
ll p[N], base = 137, mod = 29996224275833;
vector <string> a;
vector <vector <int> > sor;
vector <vector <ll> > h[2];
bool is_sorted(int idx, int l, int r){
r = min(r, (int)a[0].size() - 1);
l = max(l, 0);
if(l == r) return 1;
l++;
return sor[idx][r] - sor[idx][l - 1] == r - l + 1;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
p[0] = 1;
for(int i = 1 ; i < N ; i++){
p[i] = 1LL * p[i - 1] * base % mod;
}
cin >> n;
a.resize(n);
for(auto &i : a) cin >> i;
map <string, int> mp;
vector <int> id(n);
for(int i = 0 ; i < n ; i++){
string b = a[i];
sort(b.begin(), b.end());
if(mp.find(b) == mp.end()){
mp[b] = mp.size();
}
id[i] = mp[b];
}
vector <int> all;
for(int i = 0 ; i < n ; i++){
all.push_back(i);
}
sort(all.begin(), all.end(), [&](int i, int j){
if(id[i] == id[j]) return a[i] < a[j];
return id[i] < id[j];
});
vector <string> new_a(n);
vector <int> new_id(n);
for(int i = 0 ; i < n ; i++){
new_a[i] = a[all[i]];
new_id[i] = id[all[i]];
}
swap(a, new_a);
swap(id, new_id);
sor.resize(n, vector <int>(a[0].size()));
for(int i = 0 ; i < n ; i++){
for(int j = 1 ; j < (int)sor[i].size() ; j++){
sor[i][j] = sor[i][j - 1] + (a[i][j] >= a[i][j - 1]);
}
}
for(int itt = 0 ; itt < 2 ; itt++){
h[itt].resize(n, vector <ll>(a[0].size()));
for(int i = 0 ; i < n ; i++){
for(int j = 0 ; j < (int)a[i].size() ; j++){
if(j > 0) h[itt][i][j] = h[itt][i][j - 1];
h[itt][i][j] = (h[itt][i][j] + 1LL * (a[i][j] - 'a' + 1) * p[j]) % mod;
}
reverse(a[i].begin(), a[i].end());
}
}
for(int i = 0 ; i < n ; i++){
reverse(h[1][i].begin(), h[1][i].end());
h[1][i].push_back(mod);
}
map <ll, int> cm;
for(auto &i : h){
for(auto &j : i){
for(auto &k : j){
cm[k];
}
}
}
int x = 0;
for(auto &i : cm) i.second = x++;
for(auto &i : h){
for(auto &j : i){
for(auto &k : j){
k = cm[k];
}
}
}
ll ans = 0;
if(a[0].size() > SQ){
for(int i = 0 ; i < n ; i++){
for(int j = i + 1 ; j < n ; j++){
if(id[i] != id[j]){
ans += 1337;
continue;
}
int L = -1;
{
int l = 0, r = (int)a[0].size() - 1;
while(l <= r){
int mid = (l + r) / 2;
if(h[0][i][mid] == h[0][j][mid]) l = mid + 1;
else r = mid - 1;
}
L = r;
}
int R = n;
{
int l = 0, r = (int)a[0].size() - 1;
while(l <= r){
int mid = (l + r) / 2;
if(h[1][i][mid] == h[1][j][mid]) r = mid - 1;
else l = mid + 1;
}
R = l;
}
if(is_sorted(i, L + 1, R - 1) || is_sorted(j, L + 1, R + 1)) ans++;
else ans += 2;
}
}
}
else{
ll ones = 0;
for(int p = -1 ; p < (int)a[0].size() - 1 ; p++){
for(int iii = 0 ; iii < n ;){
int jjj = iii;
while(jjj < n && id[iii] == id[jjj]) jjj++;
for(int ii = iii ; ii < jjj ;){
int jj = ii;
while(jj < jjj && (p == -1 || h[0][ii][p] == h[0][jj][p])) jj++;
for(int s = (int)a[0].size() ; s > p + 1 ; s--){
for(int i = ii ; i < jj ;){
int j = i;
while(j < jj && a[i][p + 1] == a[j][p + 1]) j++;
for(int k = i ; k < j ; k++){
if(is_sorted(k, p + 1, s - 1)) ones += cnt_all[26][h[1][k][s]] - cnt_all[a[k][s - 1] - 'a'][h[1][k][s]];
else ones += cnt_sorted[26][h[1][k][s]] - cnt_sorted[a[k][s - 1] - 'a'][h[1][k][s]];
}
for(int k = i ; k < j ; k++){
cnt_all[26][h[1][k][s]]++;
cnt_all[a[k][s - 1] - 'a'][h[1][k][s]]++;
if(is_sorted(k, p + 1, s - 1)){
cnt_sorted[26][h[1][k][s]]++;
cnt_sorted[a[k][s - 1] - 'a'][h[1][k][s]]++;
}
}
i = j;
}
for(int k = ii ; k < jj ; k++){
cnt_all[26][h[1][k][s]] = 0;
cnt_all[a[k][s - 1] - 'a'][h[1][k][s]] = 0;
cnt_sorted[26][h[1][k][s]] = 0;
cnt_sorted[a[k][s - 1] - 'a'][h[1][k][s]] = 0;
}
}
ii = jj;
}
iii = jjj;
}
}
map <int, int> groups;
for(auto &i : id) groups[i]++;
ll pairs = 0;
for(auto &i : groups){
pairs += 1LL * i.second * (n - i.second);
}
pairs /= 2;
ans += 1337 * pairs;
pairs = 1LL * n * (n - 1) / 2 - pairs;
ans += ones;
pairs -= ones;
ans += 2 * pairs;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[3030][110][2];
int main() {
int l, n, a[1000], b[1000], i, j, k, len, wid;
long long ans;
cin >> n >> l;
for (i = 0; i < n; i++) cin >> a[i] >> b[i];
for (i = 0; i < n; i++) {
d[a[i]][i][0]++;
d[b[i]][i][1]++;
}
for (i = 0; i <= l; i++) {
for (j = 0; j < n; j++) {
wid = a[j];
len = b[j];
if (i >= wid)
for (k = 0; k < n; k++) {
if (k == j) continue;
if (a[k] == len)
d[i][j][0] += d[i - wid][k][0], d[i][j][0] %= 1000000007;
if (b[k] == len && a[k] != b[k])
d[i][j][0] += d[i - wid][k][1], d[i][j][0] %= 1000000007;
}
swap(len, wid);
if (i >= wid && len != wid)
for (k = 0; k < n; k++) {
if (k == j) continue;
if (a[k] == len)
d[i][j][1] += d[i - wid][k][0], d[i][j][1] %= 1000000007;
if (b[k] == len && a[k] != b[k])
d[i][j][1] += d[i - wid][k][1], d[i][j][1] %= 1000000007;
}
}
}
ans = 0;
for (j = 0; j < n; j++)
if (a[j] != b[j])
ans += d[l][j][0] + d[l][j][1];
else
ans += d[l][j][0];
cout << ans % 1000000007;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int L = 3005, N = 105, MOD = 1000000007;
long long dp[L][N][2];
int n, l, bs[N][2];
int main() {
cin >> n >> l;
for (int i = (0), _i = (n - 1); i <= _i; ++i) {
cin >> bs[i][0] >> bs[i][1];
}
for (int li = (1), _li = (l + 1 - 1); li <= _li; ++li) {
for (int t = (0), _t = (n - 1); t <= _t; ++t) {
for (int dir = (0), _dir = ((bs[t][0] == bs[t][1] ? 1 : 2) - 1);
dir <= _dir; ++dir) {
if (li - bs[t][dir] == 0) {
dp[li][t][dir] = (dp[li][t][dir] + 1) % MOD;
} else if (li - bs[t][dir] > 0) {
for (int pt = (0), _pt = (n - 1); pt <= _pt; ++pt) {
if (pt != t) {
for (int pdir = (0),
_pdir = ((bs[pt][0] == bs[pt][1] ? 1 : 2) - 1);
pdir <= _pdir; ++pdir) {
if (bs[t][dir] == bs[pt][1 - pdir]) {
dp[li][t][dir] =
(dp[li][t][dir] + dp[li - bs[t][dir]][pt][pdir]) % MOD;
}
}
}
}
}
}
}
}
int res = 0;
for (int t = (0), _t = (n - 1); t <= _t; ++t) {
for (int dir = (0), _dir = ((bs[t][0] == bs[t][1] ? 1 : 2) - 1);
dir <= _dir; ++dir) {
res = (res + dp[l][t][dir]) % MOD;
}
}
printf("%d", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 250;
const int MOD = 1000000007;
struct data {
int type;
int width, length;
} a[N];
int f[3050][250], n, cnt, m;
int main() {
memset(f, 0, sizeof(f));
scanf("%d%d", &n, &m);
cnt = n;
for (int i = 1, L, W; i <= cnt; i++) {
scanf("%d%d", &L, &W);
a[i].length = L, a[i].width = W, a[i].type = i;
f[L][i] = (f[L][i] + 1) % MOD;
if (L != W) {
n++;
a[n].length = W, a[n].width = L, a[n].type = i;
f[W][n] = (f[W][n] + 1) % MOD;
}
}
for (int L = 0; L <= m; L++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i].type != a[j].type && a[j].width == a[i].length &&
L >= a[i].length) {
f[L][i] = (f[L][i] + f[L - a[i].length][j]) % MOD;
}
int ans = 0;
for (int i = 1; i <= n; i++) ans = (ans + f[m][i]) % MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 250;
const int MOD = 1000000007;
struct data {
int type;
int width, length;
} a[N];
int f[3050][250], n, cnt, m;
int main() {
memset(f, 0, sizeof(f));
scanf("%d%d", &n, &m);
cnt = n;
for (int i = 1, L, W; i <= cnt; i++) {
scanf("%d%d", &L, &W);
a[i].length = L, a[i].width = W, a[i].type = i;
f[L][i] = (f[L][i] + 1) % MOD;
if (L != W) {
n++;
a[n].length = W, a[n].width = L, a[n].type = i;
f[W][n] = (f[W][n] + 1) % MOD;
}
}
for (int L = 0; L <= m; L++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i].type != a[j].type && a[j].width == a[i].length &&
L >= a[i].length) {
f[L][i] = (f[L][i] + f[L - a[i].length][j]) % MOD;
}
int ans = 0;
for (int i = 1; i <= n; i++) ans = (ans + f[m][i]) % MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:56777216")
const long long MOD = 1000000007;
long long dp[100][3001][2];
int n, l;
int a[100], b[100];
long long Dp(int type, int i, int rotated) {
int width = rotated ? b[type] : a[type];
int height = rotated ? a[type] : b[type];
if (width > i) return 0;
long long& r = dp[type][i][rotated];
if (r != -1) {
return r;
}
r = 0;
if (width == i) {
r = 1;
return r;
}
int j = i - width;
for (int type2 = 0; type2 < n; type2++) {
if (type == type2) continue;
int lim = a[type2] == b[type2] ? 1 : 2;
for (int rotated2 = 0; rotated2 < lim; rotated2++) {
int width2 = rotated2 ? b[type2] : a[type2];
if (j >= width2 && width2 == height) {
r = (r + Dp(type2, j, rotated2)) % MOD;
}
}
}
return r;
}
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i], &b[i]);
}
memset(dp, -1, sizeof(dp));
long long ans = 0;
for (int type = 0; type < n; type++) {
int lim = a[type] == b[type] ? 1 : 2;
for (int rotated = 0; rotated < lim; rotated++) {
ans = (ans + Dp(type, l, rotated)) % MOD;
}
}
printf("%d\n", int(ans));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const int MOD = INF + 7;
struct block {
int a, b;
};
block m[100 + 1];
long long dp[3000 + 1][100 + 1][2];
int main() {
int n, len;
scanf("%d%d", &n, &len);
for (int i = 0; i < n; ++i) scanf("%d%d", &m[i].a, &m[i].b);
for (int i = 1; i <= len; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < n; ++k) {
if (i == m[j].a) dp[i][j][0] = 1;
if (i - m[j].a > 0 && m[j].a == m[k].b && j != k)
dp[i][j][0] += dp[i - m[j].a][k][0];
if (i - m[j].a > 0 && m[j].a == m[k].a && j != k)
dp[i][j][0] += dp[i - m[j].a][k][1];
if (m[j].a != m[j].b) {
if (i == m[j].b) dp[i][j][1] = 1;
if (i - m[j].b > 0 && m[j].b == m[k].b && j != k)
dp[i][j][1] += dp[i - m[j].b][k][0];
if (i - m[j].b > 0 && m[j].b == m[k].a && j != k)
dp[i][j][1] += dp[i - m[j].b][k][1];
}
dp[i][j][0] %= MOD;
dp[i][j][1] %= MOD;
}
long long res = 0;
for (int j = 0; j < n; ++j)
for (int k = 0; k < 2; ++k) res = (res + dp[len][j][k]) % MOD;
printf("%I64d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
int n, l;
long long a[102], b[102];
long long dp[2 * 3002][102][2];
int main() {
while (cin >> n >> l) {
for (int i = 0; i < n; ++i) {
cin >> a[i] >> b[i];
}
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; ++i) {
dp[a[i]][i][0] = 1LL;
if (a[i] != b[i]) {
dp[b[i]][i][1] = 1LL;
}
}
for (int i = 1; i <= l; ++i) {
for (int j = 0; j < n; ++j) {
if (dp[i][j][0]) {
for (int k = 0; k < n; ++k) {
if (k != j) {
if (a[k] == b[j]) {
dp[i + b[j]][k][0] = (dp[i + b[j]][k][0] + dp[i][j][0]) % mod;
} else if (b[k] == b[j]) {
dp[i + b[j]][k][1] = (dp[i + b[j]][k][1] + dp[i][j][0]) % mod;
}
}
}
}
if (dp[i][j][1]) {
for (int k = 0; k < n; ++k) {
if (k != j) {
if (a[k] == a[j]) {
dp[i + a[j]][k][0] = (dp[i + a[j]][k][0] + dp[i][j][1]) % mod;
} else if (b[k] == a[j]) {
dp[i + a[j]][k][1] = (dp[i + a[j]][k][1] + dp[i][j][1]) % mod;
}
}
}
}
}
}
long long ans = 0LL;
for (int i = 0; i < n; ++i) {
ans = (ans + dp[l][i][0]) % mod;
ans = (ans + dp[l][i][1]) % mod;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 218;
const int MAXM = 3200;
const long long MOD = 1000000007LL;
int a[MAXN], b[MAXN];
long long dp[MAXM][MAXN];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i], &b[i]);
++dp[a[i]][i];
if (a[i] != b[i]) {
a[n + i] = b[i];
b[n + i] = a[i];
++dp[a[n + i]][n + i];
}
}
for (int i = 1; i <= m; ++i) {
for (int j = 0; j < n + n; ++j) {
if (dp[i][j] == 0) {
continue;
}
dp[i][j] %= MOD;
for (int k = 0; k < n + n; ++k) {
if (j % n != k % n && a[k] == b[j]) {
dp[i + a[k]][k] += dp[i][j];
}
}
}
}
printf("%d\n", (int)(accumulate(dp[m], dp[m] + n + n, 0LL) % MOD));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 100 + 10;
const long long Maxl = 3000 + 10;
const long long Mod = 1000 * 1000 * 1000 + 7;
bool mark[2][Maxn][Maxl];
long long edge[Maxn][Maxn];
long long d[2][Maxn][Maxl];
long long n, l;
long long out;
long long a[2][Maxn];
void input() {
cin >> n >> l;
for (long long i = 0; i < n; i++) cin >> a[0][i] >> a[1][i];
}
long long calc(long long cur, long long rem, bool rotate = 0) {
if (rem < a[rotate][cur]) return 0;
if (mark[rotate][cur][rem]) return d[rotate][cur][rem];
mark[rotate][cur][rem] = true;
if (a[rotate][cur] == rem) {
d[rotate][cur][rem] = 1;
return 1;
}
for (long long i = 0; i < n; i++)
if (i != cur) {
if (a[0][i] == a[!rotate][cur])
d[rotate][cur][rem] += calc(i, rem - a[rotate][cur], 0);
else if (a[1][i] == a[!rotate][cur])
d[rotate][cur][rem] += calc(i, rem - a[rotate][cur], 1);
}
d[rotate][cur][rem] %= Mod;
return d[rotate][cur][rem];
}
void calc_all() {
for (long long i = 0; i < n; i++)
out += calc(i, l, 0) + (calc(i, l, 1) * (!(a[0][i] == a[1][i])));
out %= Mod;
}
void output() { cout << out << "\n"; }
int main() {
input();
calc_all();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[3001][101][101];
int total[3001][101];
int main() {
int n, l;
cin >> n >> l;
pair<int, int> type[n];
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
type[i] = make_pair(a, b);
}
for (int i = 0; i <= 100; i++) total[0][i] = 1;
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
int a = type[j].first;
int b = type[j].second;
if (i - a >= 0) {
dp[i][j][b] = total[i - a][a] - dp[i - a][j][a];
if (dp[i][j][b] < 0) dp[i][j][b] += 1000000007;
total[i][b] = (total[i][b] + dp[i][j][b]) % 1000000007;
}
if (i - b >= 0 && a != b) {
dp[i][j][a] = total[i - b][b] - dp[i - b][j][b];
if (dp[i][j][a] < 0) dp[i][j][a] += 1000000007;
total[i][a] = (total[i][a] + dp[i][j][a]) % 1000000007;
}
}
}
int ans = 0;
for (int i = 0; i <= 100; i++) {
ans = (ans + total[l][i]) % 1000000007;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
vector<int> a(n * 2, 0);
vector<int> b(n * 2, 0);
vector<vector<int> > d(l + 1, vector<int>(n * 2, 0));
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (a[i] != b[i]) {
a[n + i] = b[i];
b[n + i] = a[i];
} else {
a[n + i] = l + 1;
b[n + i] = l + 1;
}
}
for (int c = 1; c <= l; c++) {
for (int i = 0; i < n * 2; i++) {
int aa = a[i];
int caa = c - aa;
if (caa >= 0) {
int countPrev = 0;
if (caa == 0) {
countPrev = 1;
} else {
for (int ii = 0; ii < n * 2; ii++) {
if (ii == i || ii + n == i || ii == i + n) continue;
if (a[i] != b[ii]) continue;
countPrev += d[caa][ii];
countPrev = countPrev % 1000000007;
}
}
d[c][i] += countPrev;
}
}
}
int res = 0;
for (int i = 0; i < n * 2; i++) {
res += d[l][i];
res = res % 1000000007;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int MAXLEN = 3002;
const int MAXTYPE = 102;
const int MAXWITH = 102;
int dp1[MAXLEN][MAXTYPE][MAXWITH], dp2[MAXTYPE];
int width[MAXTYPE * 2], length[MAXTYPE * 2];
bool flag[MAXTYPE * 2];
void up(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
int n, len;
while (scanf("%d%d", &n, &len) != EOF) {
int Max(0);
memset(flag, 0, sizeof(flag));
for (int i = 1; i <= 2 * n; i += 2) {
scanf("%d%d", &width[i], &length[i]);
width[i + 1] = length[i];
length[i + 1] = width[i];
Max = max(Max, max(width[i], length[i]));
if (length[i] == width[i]) flag[i] = 1;
}
n *= 2;
memset(dp1, 0, sizeof(dp1));
memset(dp2, 0, sizeof(dp2));
for (int i = 1; i <= n; ++i)
if (!flag[i]) dp1[length[i]][(i + 1) / 2][width[i]]++;
for (int i = 1; i <= len; ++i)
for (int j = 1; j <= Max; ++j) {
int sum(0);
for (int k = 1; k <= n / 2; ++k) {
up(sum, dp1[i][k][j]);
}
for (int k = 1; k <= n / 2; ++k)
dp2[k] = (sum - dp1[i][k][j] + mod) % mod;
for (int k = 1; k <= n; ++k) {
if (!flag[k] && i + length[k] <= len && length[k] == j)
up(dp1[i + length[k]][(k + 1) / 2][width[k]], dp2[(k + 1) / 2]);
}
}
int ans(0);
for (int i = 1; i <= n; ++i)
if (!flag[i]) up(ans, dp1[len][(i + 1) / 2][width[i]]);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 3200;
using namespace std;
int n, l;
int a[N][3], b[N][3];
int dp[N][105][3];
void add(int &a, int &b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> l;
for (int i = 1; i <= n; i++) {
cin >> a[i][0] >> b[i][0];
a[i][1] = b[i][0];
b[i][1] = a[i][0];
}
for (int i = 1; i <= n; i++) {
dp[a[i][0]][i][0] += 1;
if (a[i][0] != b[i][0]) dp[b[i][0]][i][1] += 1;
}
for (int i = 1; i <= l; i++) {
for (int cur = 1; cur <= n; cur++) {
for (int rot1 = 0; rot1 <= 1; rot1++) {
for (int to = 1; to <= n; to++) {
if (to != cur)
for (int rot2 = 0; rot2 <= 1; rot2++) {
if (a[to][0] == b[to][0] && rot2 == 1) continue;
if (b[cur][rot1] == a[to][rot2])
add(dp[i + a[to][rot2]][to][rot2], dp[i][cur][rot1]);
}
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 1; j++) {
add(ans, dp[l][i][j]);
}
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 50, mod = 1e9 + 7;
long long n, a[N][3], l, dp[N][N][3];
int main() {
cin >> n >> l;
for (int i = 1; i <= n; i++) {
cin >> a[i][0] >> a[i][1];
++dp[a[i][0]][i][0];
if (a[i][1] != a[i][0]) ++dp[a[i][1]][i][1];
}
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= n; j++) {
for (int x = 0; x <= 1; x++) {
if (x == 1 && a[j][0] == a[j][1]) continue;
for (int k = 1; k <= n; k++) {
for (int y = 0; y <= 1; y++) {
if (j != k && a[j][x] == a[k][1 - y] && i > a[j][x])
dp[i][j][x] += dp[i - a[j][x]][k][y];
dp[i][j][x] = dp[i][j][x] % mod;
}
}
}
}
}
int maxs = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 1; j++) {
maxs += dp[l][i][j];
maxs = maxs % mod;
}
}
cout << maxs;
}
|
#include <bits/stdc++.h>
using namespace std;
double EPS = 1e-10;
double EQ(double a, double b) { return abs(a - b) < EPS; }
void fast_stream() { std::ios_base::sync_with_stdio(0); }
int a[1001][2];
int dp[3001][201][2];
int n, l;
const int mod = 1000000007;
int dfs(int len, int prv, int flip) {
if (dp[len][prv][flip] >= 0)
return dp[len][prv][flip];
else if (len == 0)
return 1;
long long res = 0;
for (int i = 0; i < n; i++) {
if (i == prv) continue;
int prvWidth = a[prv][flip ^ 1];
for (int j = 0; j < 2; j++) {
if (j == 1 && a[i][j] == a[i][j ^ 1]) continue;
int width = a[i][j ^ 1];
int curLen = a[i][j];
if ((prv == 110 || prvWidth == curLen) && len - curLen >= 0)
res = (res + dfs(len - curLen, i, j)) % mod;
}
}
return dp[len][prv][flip] = res % mod;
}
void solve() {
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
memset(dp, -1, sizeof(dp));
int res = dfs(l, 110, 0);
cout << res << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:200000000")
const double EPS = 1E-9;
const int INF = 1000000000;
const long long INF64 = (long long)1E18;
const double PI = 3.1415926535897932384626433832795;
const int MOD = INF + 7;
int a[1100], b[1100], z[3100][110][2][2], n, l;
vector<int> g[1100];
bool eq[110][110];
int rec(int l, int pr, int tp, int fl) {
if (l < 0) return 0;
if (l == 0 && fl) return 0;
if (l == 0) return 1;
if (z[l][pr][tp][fl] != -1) return z[l][pr][tp][fl];
int len = a[pr];
if (tp) len = b[pr];
int res = 0;
for (int i = 0; i < (int)(g[len].size()); i++) {
int id = g[len][i];
if (id == pr || fl && eq[pr][id]) continue;
if (a[id] == len)
res += rec(l - a[id], id, 1, 0);
else if (b[id] == len)
res += rec(l - b[id], id, 0, 0);
if (res >= MOD) res -= MOD;
}
return z[l][pr][tp][fl] = res;
}
vector<int> out;
void recwrite(int l, int pr, int tp, int fl) {
out.push_back(pr);
if (l < 0) throw;
if (l == 0 && fl) throw;
if (l == 0) {
for (int i = 0; i < (int)(out.size()); i++) cout << out[i] + 1 << ' ';
cout << endl;
out.pop_back();
return;
}
int len = a[pr];
if (tp) len = b[pr];
int res = z[l][pr][tp][fl];
for (int i = 0; i < (int)(g[len].size()); i++) {
int id = g[len][i];
if (id == pr || fl && eq[pr][id]) continue;
if (a[id] == len) {
if (rec(l - a[id], id, 1, 0)) recwrite(l - a[id], id, 1, 0);
} else if (b[id] == len)
if (rec(l - b[id], id, 0, 0)) recwrite(l - b[id], id, 0, 0);
if (res >= MOD) res -= MOD;
}
out.pop_back();
}
int solve(int id) {
int cnt = 0;
for (int i = 0; i < (int)(n); i++)
if (eq[id][i]) {
if (i < id) return 0;
cnt++;
}
int s1 = 0, s2 = 0;
long long cof = 1;
long long res = 0;
for (int len = 1;; len++) {
if (cnt == 1 && len > 1) break;
if (len % 2 == 1) {
s1 += a[id];
s2 += b[id];
} else {
s1 += b[id];
s2 += a[id];
}
if (s1 > l && s2 > l) break;
if (len == 1)
cof = cof * cnt % MOD;
else
cof = cof * (cnt - 1) % MOD;
if (l == s1 || l == s2) {
res += cof;
res %= MOD;
}
res += cof * rec(l - s1, id, 1, 1);
if (a[id] != b[id]) res += cof * rec(l - s2, id, 0, 1);
res %= MOD;
}
return (int)res;
}
int main() {
cin >> n >> l;
for (int i = 0; i < (int)(n); i++) {
cin >> a[i] >> b[i];
if (a[i] > b[i]) swap(a[i], b[i]);
g[a[i]].push_back(i);
if (a[i] != b[i]) g[b[i]].push_back(i);
}
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++)
if (a[i] == a[j] && b[i] == b[j]) eq[i][j] = true;
memset(z, -1, sizeof(z));
int res = 0;
for (int i = 0; i < (int)(n); i++) {
res += rec(l - b[i], i, 0, 0);
res %= MOD;
if (a[i] != b[i]) {
res += rec(l - a[i], i, 1, 0);
}
res %= MOD;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int M = 1000000000 + 7;
int n, l, a[2][100];
int dp[30001][100][2], res = 0;
int main() {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; ++i) scanf("%d %d", &a[0][i], &a[1][i]);
for (int i = 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) % M;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
int arr[102][2];
long long memo[105][2][3002];
int mod = 1000000007;
long long DP(int lst, int ldim, int rem) {
if (rem == 0) return 1;
if (rem < 0) return 0;
long long& m = memo[lst][ldim][rem];
if (m != -1) return m;
int eq = arr[lst][!ldim];
m = 0;
for (int i = 0; i < n; i++) {
if (i == lst) continue;
if (eq == arr[i][0]) {
m += DP(i, 0, rem - eq);
if (m > mod) m %= mod;
} else if (eq == arr[i][1]) {
m += DP(i, 1, rem - eq);
if (m > mod) m %= mod;
}
}
return m;
}
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; i++) scanf("%d%d", &arr[i][0], &arr[i][1]);
memset((memo), (-1), sizeof(memo));
long long m = 0;
for (int i = 0; i < n; i++) {
m += DP(i, 0, l - arr[i][0]);
if (m > mod) m %= mod;
if (arr[i][0] == arr[i][1]) continue;
m += DP(i, 1, l - arr[i][1]);
if (m > mod) m %= mod;
}
cout << m;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Mx = 256, Mod = 1000 * 1000 * 1000 + 7;
vector<pair<int, int>> V, N[Mx];
int dp[4096][Mx];
void add(int x, int y, int b) {
int id = V.size();
V.push_back({x, y});
for (int i = 0; i < id - b; i++) {
if (V[i].second == x) N[id].push_back({i, x});
if (V[i].first == y) N[i].push_back({id, y});
}
}
int main() {
int n, l, a = 0;
cin >> n >> l;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
add(x, y, 0);
if (x != y) add(y, x, 1);
}
for (int i = 0; i < V.size(); i++) dp[V[i].first][i] = 1;
for (int i = 1; i <= l; i++)
for (int j = 0; j < V.size(); j++)
for (auto p : N[j])
if (p.second <= i)
dp[i][j] = (dp[i][j] + dp[i - p.second][p.first]) % Mod;
for (int i = 0; i < V.size(); i++) a = (a + dp[l][i]) % Mod;
cout << a;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int maxn = 105;
int N, L;
int a[maxn];
int b[maxn];
long long dp[3005][maxn][2];
int main() {
cin >> N >> L;
for (int i = 0; i < N; ++i) {
scanf("%d%d", &a[i], &b[i]);
}
for (int i = 0; i < N; ++i) {
dp[a[i]][i][0] = 1;
dp[b[i]][i][1] = 1;
}
for (int i = 1; i <= L; ++i) {
for (int j = 0; j < N; ++j) {
for (int k = 0; k < N; ++k) {
if (k == j) continue;
if (i >= a[j]) {
if (a[j] == b[k]) {
dp[i][j][0] += dp[i - a[j]][k][0];
} else if (a[j] == a[k]) {
dp[i][j][0] += dp[i - a[j]][k][1];
}
}
if (i >= b[j]) {
if (b[j] == b[k]) {
dp[i][j][1] += dp[i - b[j]][k][0];
} else if (b[j] == a[k]) {
dp[i][j][1] += dp[i - b[j]][k][1];
}
}
}
dp[i][j][0] %= MOD;
dp[i][j][1] %= MOD;
}
}
long long ans = 0;
for (int i = 0; i < N; ++i) {
ans += dp[L][i][0];
if (a[i] != b[i]) ans += dp[L][i][1];
}
ans %= MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4001, M = 100;
long long int mod = 1e9 + 7;
long long int dp[N][M][2];
long long int n, l;
pair<long long int, long long int> a[M];
long long int solve(int le, int prev, int ro) {
if (le == 0) return 1;
if (le < 0) return 0;
if (dp[le][prev][ro] != -1) return dp[le][prev][ro];
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (le == l) {
ans = (ans + solve(le - a[i].first, i, 0)) % mod;
if (a[i].first != a[i].second)
ans = (ans + solve(le - a[i].second, i, 1)) % mod;
continue;
}
if (i != prev) {
if (ro && a[prev].first == a[i].first)
ans = (ans + solve(le - a[i].first, i, 0)) % mod;
if (ro && a[prev].first == a[i].second && a[i].first != a[i].second)
ans = (ans + solve(le - a[i].second, i, 1)) % mod;
if (ro == 0 && a[prev].second == a[i].first)
ans = (ans + solve(le - a[i].first, i, 0)) % mod;
if (ro == 0 && a[prev].second == a[i].second && a[i].first != a[i].second)
ans = (ans + solve(le - a[i].second, i, 1)) % mod;
}
}
return dp[le][prev][ro] = ans;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
cout << solve(l, 0, 0) << endl;
}
|
#include <bits/stdc++.h>
const int MOD = 1000000007;
int n, lim;
int x[2][200];
int dp[120][2][3040];
bool done[120][2][3040];
int f(int lst, int tp, int left) {
if (left == 0) return 1;
if (done[lst][tp][left]) return dp[lst][tp][left];
int rn = 0;
done[lst][tp][left] = 1;
for (int i = 0; i < n; i++) {
if (i != lst) {
if (x[0][i] == x[tp][lst] && x[0][i] <= left)
rn = (rn + f(i, 1, left - x[0][i])) % MOD;
if (x[1][i] != x[0][i] && x[1][i] == x[tp][lst] && x[1][i] <= left)
rn = (rn + f(i, 0, left - x[1][i])) % MOD;
}
}
dp[lst][tp][left] = rn;
return dp[lst][tp][left];
}
int main() {
while (~scanf("%d %d", &n, &lim)) {
for (int i = 0; i < n; i++) scanf("%d %d", &x[0][i], &x[1][i]);
memset(done, 0, sizeof(done));
int ans = 0;
for (int i = 0; i < n; i++) {
if (x[0][i] <= lim) ans = (ans + f(i, 1, lim - x[0][i])) % MOD;
if (x[0][i] != x[1][i] && x[1][i] <= lim)
ans = (ans + f(i, 0, lim - x[1][i])) % MOD;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int toMod = 1000000007;
int n, l;
pair<int, int> a[105];
int f[3005][105][2];
inline void init() {
memset(f, -1, sizeof f);
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i].first, &a[i].second);
}
}
int rec(int x, int y, int z) {
if (x < 0) return 0;
if (!x) return 1;
if (f[x][y][z] != -1) return f[x][y][z];
int res = 0;
pair<int, int> cur = a[y];
if (z) swap(cur.first, cur.second);
for (int i = 0; i < n; ++i) {
if (i == y) continue;
if (y == n || a[i].first == cur.second) {
res += rec(x - a[i].first, i, 0);
if (res >= toMod) res -= toMod;
}
if (a[i].first == a[i].second) continue;
if (y == n || a[i].second == cur.second) {
res += rec(x - a[i].second, i, 1);
if (res >= toMod) res -= toMod;
}
}
return f[x][y][z] = res;
}
int main() {
init();
a[n] = pair<int, int>(-12343678, -12343678);
int res = rec(l, n, 0);
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int dp[3005][105][2];
vector<array<int, 2>> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
v.push_back({a, b});
}
for (int i = 0; i < n; i++) {
int a = v[i][0], b = v[i][1];
dp[a][i][0] += 1;
if (a != b) dp[b][i][1] += 1;
}
for (int li = 1; li <= l; li++) {
for (int la = 0; la < n; la++) {
for (int ti = 0; ti < 2; ti++) {
for (int i = 0; i < n; i++) {
if (i == la) {
continue;
}
int a = v[i][0], b = v[i][1];
if (li + a <= l && v[la][(ti + 1) % 2] == a) {
dp[li + a][i][0] = (dp[li + a][i][0] + dp[li][la][ti]) % mod;
}
if (li + b <= l && v[la][(ti + 1) % 2] == b && a != b) {
dp[li + b][i][1] = (dp[li + b][i][1] + dp[li][la][ti]) % mod;
}
}
}
}
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
ans = (ans + dp[l][i][j]) % mod;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
const long long MX = 2e5 + 5;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
long long power_md(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res = (res % md * a % md) % md;
a = (a % md * a % md) % md;
n /= 2;
}
res %= md;
return res;
}
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= a;
a = a * a;
n /= 2;
}
return res;
}
long long abst(long long a) { return ((a < 0) ? (-1 * a) : (a)); }
class cmp_set {
public:
bool operator()(long long a, long long b) { return a > b; }
};
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) long long idx,
__attribute__((unused)) long long LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, long long idx, long long LINE_NUM, Head H,
Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
long long n, len;
long long li[105], wi[105];
long long dp[105][3005][2];
long long fun(long long prev, long long l, long long rot) {
if (l < 0)
return 0;
else if (l == 0)
return 1;
if (dp[prev][l][rot] != -1) return dp[prev][l][rot];
long long res = 0;
long long wp;
if (prev == 0)
wp = -1;
else {
if (rot)
wp = li[prev];
else
wp = wi[prev];
}
for (long long i = 1; i <= n; i++) {
if (i == prev) continue;
if (wp == -1) {
res = (res % md + fun(i, l - li[i], (long long)0) % md) % md;
if (wi[i] != li[i])
res = (res % md + fun(i, l - wi[i], (long long)1) % md) % md;
} else {
if (li[i] == wp)
res = (res % md + fun(i, l - li[i], (long long)0) % md) % md;
if ((wi[i] == wp) && (wi[i] != li[i]))
res = (res % md + fun(i, l - wi[i], (long long)1) % md) % md;
}
}
return dp[prev][l][rot] = res;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
memset(dp, -1, sizeof(dp));
cin >> n >> len;
for (long long i = 1; i <= n; i++) {
cin >> li[i] >> wi[i];
}
long long res = fun((long long)0, len, (long long)0) % md;
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const long long mod = 1000 * 1000 * 1000 + 7;
const long long mod1 = 998244353;
const long long INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (long long)(res * x);
y = y >> 1;
x = (long long)(x * x);
}
return res;
}
long long dp[3205][105][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, l;
cin >> n >> l;
long long a[n];
long long b[n];
for (int(i) = (0); (i) < (n); ++(i)) {
cin >> a[i] >> b[i];
if (a[i] != b[i]) {
dp[a[i]][i][0] = 1;
dp[b[i]][i][1] = 1;
} else {
dp[a[i]][i][0] = 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 (k != j and a[k] == b[k]) {
if (dp[i][j][0] > 0 and a[k] == b[j] and i + a[k] <= l) {
dp[i + a[k]][k][0] += dp[i][j][0] % mod;
}
if (dp[i][j][1] > 0 and a[k] == a[j] and i + a[k] <= l) {
dp[i + a[k]][k][0] += dp[i][j][1] % mod;
}
dp[i + a[k]][k][0] %= mod;
}
if (k != j and a[k] != b[k]) {
if (dp[i][j][0] > 0 and a[k] == b[j] and i + a[k] <= l) {
dp[i + a[k]][k][0] += dp[i][j][0] % mod;
dp[i + a[k]][k][0] %= mod;
}
if (dp[i][j][0] > 0 and b[k] == b[j] and i + b[k] <= l) {
dp[i + b[k]][k][1] += dp[i][j][0] % mod;
dp[i + b[k]][k][1] %= mod;
}
if (dp[i][j][1] > 0 and a[k] == a[j] and i + a[k] <= l) {
dp[i + a[k]][k][0] += dp[i][j][1] % mod;
dp[i + a[k]][k][0] %= mod;
}
if (dp[i][j][1] > 0 and b[k] == a[j] and i + b[k] <= l) {
dp[i + b[k]][k][1] += dp[i][j][1] % mod;
dp[i + b[k]][k][1] %= mod;
}
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += (dp[l][i][0] + dp[l][i][1]) % mod;
ans %= mod;
}
cout << ans % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[100010][220] = {0};
long long a[220], b[220];
int main() {
int n, len;
cin >> n >> len;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &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 = 1; i <= len; i++) {
for (int j = 1; j <= 2 * n; j++) {
if (!dp[i][j]) continue;
for (int k = 1; k <= 2 * n; k++) {
if (j % n != k % n && b[j] == a[k]) {
dp[i + a[k]][k] += dp[i][j];
dp[i + a[k]][k] %= 1000000007;
}
}
}
}
long long ans = 0;
for (int i = 1; i <= 2 * n; i++) {
(ans += dp[len][i]) %= 1000000007;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long vertdp[101][3001];
long long hordp[101][3001];
int len[101];
int width[101];
int main() {
int boardNum, fenceLength, i, j, lastType, nextType;
cin >> boardNum >> fenceLength;
for (i = 1; i <= boardNum; i++) cin >> len[i] >> width[i];
for (int length = 1; length <= fenceLength; length++) {
for (nextType = 1; nextType <= boardNum; nextType++) {
long long maxVertHor = 0, maxVertVert = 0, maxHorHor = 0, maxHorVert = 0;
if (width[nextType] < length) {
for (lastType = 1; lastType <= boardNum; lastType++) {
if (nextType != lastType && len[nextType] == width[lastType])
maxVertVert =
(maxVertVert + vertdp[lastType][length - width[nextType]]) %
1000000007;
if (nextType != lastType && len[nextType] == len[lastType])
maxVertHor =
(maxVertHor + hordp[lastType][length - width[nextType]]) %
1000000007;
}
vertdp[nextType][length] = (maxVertVert + maxVertHor) % 1000000007;
} else if (width[nextType] == length)
vertdp[nextType][length] = 1;
if (len[nextType] != width[nextType]) {
if (len[nextType] < length) {
for (lastType = 1; lastType <= boardNum; lastType++) {
if (nextType != lastType && width[nextType] == width[lastType])
maxHorVert =
(maxHorVert + vertdp[lastType][length - len[nextType]]) %
1000000007;
if (nextType != lastType && width[nextType] == len[lastType])
maxHorHor =
(maxHorHor + hordp[lastType][length - len[nextType]]) %
1000000007;
}
hordp[nextType][length] = (maxHorVert + maxHorHor) % 1000000007;
} else if (len[nextType] == length)
hordp[nextType][length] = 1;
}
}
}
long long maxAll = 0;
for (i = 1; i <= boardNum; i++)
maxAll =
(maxAll + vertdp[i][fenceLength] + hordp[i][fenceLength]) % 1000000007;
cout << maxAll << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t = 1000001;
class myData {
public:
int t;
int x;
int y;
int d;
myData(int t, int x, int y, int d) : t(t), x(x), y(y), d(d) {}
bool operator<(const myData &a) const { return (this->t < a.t); }
};
long long exponentMod(long long A, long long B, long long C) {
if (A == 0) return 0;
if (B == 0) return 1;
long long y;
if (B % 2 == 0) {
y = exponentMod(A, B / 2, C);
y = (y * y) % C;
} else {
y = A % C;
y = (y * exponentMod(A, B - 1, C) % C) % C;
}
return (long long)((y + C) % C);
}
pair<int, int> factorize(long long n) {
int ans = 1;
int c = 0;
for (long long i = 2; i * i <= n; ++i) {
while (n % i == 0) {
if (i != 2) ans *= i, c++;
n /= i;
}
}
if (n != 1) {
if (n != 2) ans *= n, c++;
}
return {ans, c};
}
map<long long, long long> bit;
int N1 = 2e5;
void update(long long i) {
for (; i <= N1; i += i & (-i)) bit[i]++;
}
long long get(long long i) {
long long ans = 0;
for (; i > 0; i -= i & (-i)) ans += bit[i];
return ans;
}
int now;
bool sortByVal(const myData &a, const myData &b) { return (a.t < b.t); }
long long ans1 = 0;
int spf[1000003];
long long calc[1000003 + 1];
long long nCk(long long n, long long k, long long mod) {
return ((((calc[n] % mod) * exponentMod(calc[k], mod - 2, mod)) % mod) *
exponentMod(calc[n - k], mod - 2, mod)) %
mod;
}
void sieve() {
spf[1] = 1;
for (int i = 2; i < 1000003; i++) spf[i] = i;
for (int i = 4; i < 1000003; i += 2) spf[i] = 2;
for (int i = 3; i * i < 1000003; i++) {
if (spf[i] == i) {
for (int j = i * i; j < 1000003; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
set<int> getFactorization(int x) {
set<int> ret;
while (x != 1) {
ret.insert(spf[x]);
x = x / spf[x];
}
return ret;
}
bool prime[1000003 + 1];
void sieve2() {
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= 1000003; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= 1000003; i += p) prime[i] = false;
}
}
}
int MEX(int a[], int n) {
set<int> s;
for (int i = 0; i < n; i++) {
s.insert(a[i]);
}
int c = 0;
for (auto i = s.begin(); i != s.end(); i++) {
if (*i == c) {
c++;
} else
break;
}
return c;
}
int smallestDivisor(int n) {
if (n % 2 == 0) return 2;
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
return n;
}
map<int, pair<int, int>> m;
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;
using INT = long long;
int a[210], b[210], tp[210];
INT dp[210][3100];
int main() {
int n, l;
cin >> n >> l;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i], &b[i]);
tp[i] = i;
}
int nn = n;
for (int i = 1; i <= n; i++) {
if (a[i] != b[i]) {
tp[++nn] = i;
a[nn] = b[i];
b[nn] = a[i];
}
}
for (int i = 1; i <= nn; i++) dp[i][a[i]] = 1;
for (int d = 1; d < 3100; d++) {
for (int i = 1; i <= nn; i++) {
if (d <= a[i]) continue;
for (int j = 1; j <= nn; j++) {
if (tp[i] == tp[j]) continue;
if (a[i] != b[j]) continue;
if (!dp[j][d - a[i]]) continue;
dp[i][d] = (dp[i][d] + dp[j][d - a[i]]) % 1000000007;
}
}
}
INT ans = 0;
for (int i = 1; i <= nn; i++) ans = (ans + dp[i][l]) % 1000000007;
ans = (ans + 1000000007) % 1000000007;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, l;
long long data[3009][2];
long long dp[3009][109][3];
void solve() {
memset(dp, 0, sizeof dp);
long long len;
for (long long i = 1; i <= l; i++) {
for (long long j = 0; j < n; j++) {
for (long long o = 0; o < 2; o++) {
len = data[j][o];
if (len > i) continue;
if (o == 1 && len == data[j][0]) continue;
if (i == len) {
dp[i][j][o] = (dp[i][j][o] + 1) % (1000000007L);
}
for (long long k = 0; k < n; k++) {
if (k == j) continue;
if (data[k][0] == len && (i - data[k][1]) >= 0) {
dp[i][j][o] = (dp[i][j][o] + dp[i - len][k][1]) % (1000000007L);
}
if (data[k][1] == len && (i - data[k][0]) >= 0) {
dp[i][j][o] = (dp[i][j][o] + dp[i - len][k][0]) % (1000000007L);
}
}
}
}
}
long long sum = 0;
for (long long i = 0; i < (long long)n; i++) {
sum = (sum + dp[l][i][0] + dp[l][i][1]) % (1000000007L);
}
sum = (sum + (1000000007L)) % (1000000007L);
cout << sum << endl;
}
int main() {
cin >> n >> l;
long long x, y;
memset(data, 0, sizeof data);
for (long long i = 0; i < (long long)n; i++) {
cin >> x >> y;
data[i][0] = x;
data[i][1] = y;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, L;
int boards[100][2];
int dp[3010][100][2];
const int md = 1000000007;
int getdp(int i, int prev, int pos) {
if (i < 0) return 0;
if (i == 0) return 1;
int &res = dp[i][prev][pos];
if (res != -1) return res;
int prevl = boards[prev][pos];
res = 0;
for (int j = 0; j < N; j++) {
if (j == prev) continue;
for (int k = 0; k < 2; k++) {
if (k == 1 && boards[j][0] == boards[j][1]) break;
int len = boards[j][k];
int wid = boards[j][1 - k];
if (wid != prevl) continue;
res += getdp(i - len, j, k);
res %= md;
}
}
return res;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> N >> L;
for (int i = 0; i < N; i++) {
cin >> boards[i][0] >> boards[i][1];
}
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 2; j++) {
if (j == 1 && boards[i][0] == boards[i][1]) break;
ans += getdp(L - boards[i][j], i, j);
ans %= md;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
int n, l, a[128][2], t[4096][128][2], w;
int main(void) {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; ++i) scanf("%d %d", &a[i][0], &a[i][1]);
for (int i = 0; i < 128; ++i)
for (int j = (a[i][0] == a[i][1]) ? 1 : 2; j-- > 0;) t[a[i][j]][i][j] = 1;
for (int i = 0; i < l; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < 2; ++k)
if (t[i][j][k])
for (int u = 0; u < n; ++u)
if (u != j)
for (int v = (a[u][0] == a[u][1]) ? 1 : 2; v-- > 0;)
if (a[j][1 - k] == a[u][v] &&
(t[i + a[u][v]][u][v] += t[i][j][k]) >= Mod)
t[i + a[u][v]][u][v] -= Mod;
for (int i = 0; i < n; ++i) (((w += t[l][i][0]) %= Mod) += t[l][i][1]) %= Mod;
printf("%d\n", w);
return 0;
}
|
#include <bits/stdc++.h>
int dp[3001][101][2];
int n, l;
int data[100][2];
const int MOD = 1000000007;
int getAns(int left, int ind, int type) {
if (left < 0) return 0;
if (left == 0) return 1;
int ret = dp[left][ind][type];
if (ret != -1) return ret;
ret = 0;
for (int i = 0; i < n; i++) {
if (i == ind) continue;
for (int j = 0; j < 2; j++) {
if (j && data[i][0] == data[i][1]) continue;
if (ind == n || data[i][j] == data[ind][1 - type])
ret = (ret + getAns(left - data[i][j], i, j)) % MOD;
}
}
return dp[left][ind][type] = ret;
}
int main(void) {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; i++) scanf("%d %d", data[i], data[i] + 1);
memset(dp, -1, sizeof(dp));
printf("%d\n", getAns(l, n, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int x, y;
} f[201];
int i, j, k, n, m, l;
long long dp[3002][201];
bool used[201];
int main() {
int i, j, k;
scanf("%d %d", &n, &l);
for (i = 0; i < n; i++) {
scanf("%d %d", &f[i << 1].x, &f[i << 1].y);
f[((i << 1) ^ 1)].x = f[i << 1].y;
f[((i << 1) ^ 1)].y = f[i << 1].x;
}
memset(dp, 0, sizeof(dp));
memset(used, true, sizeof(used));
for (i = 0; i < 2 * n; i++) {
if (f[i].x == f[i].y && i & 1) {
used[i] = false;
continue;
}
dp[f[i].x][i] = 1;
}
for (i = 1; i < l; i++)
for (j = 0; j < 2 * n; j++) {
if (!used[j]) continue;
for (k = 0; k < 2 * n; k++) {
if (!used[k]) continue;
if (j == k) continue;
if (((j) ^ 1) == k) continue;
if (f[k].x != f[j].y) continue;
if (i + f[k].x > l) continue;
dp[i + f[k].x][k] = (dp[i + f[k].x][k] + dp[i][j]) % 1000000007;
}
}
long long ans = 0;
for (i = 0; i < 2 * n; i++) ans = (ans + dp[l][i]) % 1000000007;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int dx[8] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};
vector<int> adj[300010], val(300010, 1), vis(300010, 0), dis1(300010, 0),
dis2(300010, 0);
int myrandom(int i) { return std::rand() % i; }
long long dp[10010][210];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, l;
cin >> n >> l;
vector<vector<int>> v;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a == b) {
v.push_back({a, b, i});
} else {
v.push_back({a, b, i});
v.push_back({b, a, i});
}
}
n = (int)v.size();
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
dp[v[i][1]][i] = 1;
}
for (int i = 1; i < l; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (v[j][2] != v[k][2] && v[j][1] == v[k][0]) {
dp[i + v[k][1]][k] = (dp[i + v[k][1]][k] + dp[i][j]) % 1000000007;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + dp[l][i]) % 1000000007;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, l;
cin >> n >> l;
int a[n][2];
for (int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
int dp[l][n][2];
for (int i = 0; i < l; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++) dp[i][j][k] = 0;
for (int i = 0; i < l; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++)
if (!(k == 1 && a[j][0] == a[j][1])) {
if (a[j][k] == (i + 1)) {
dp[i][j][k] = (dp[i][j][k] + 1) % MOD;
} else if (a[j][k] < (i + 1)) {
for (int t = 0; t < n; t++)
if (t != j) {
for (int p = 0; p < 2; p++)
if (a[j][k] == a[t][1 - p])
dp[i][j][k] = (dp[i][j][k] + dp[i - a[j][k]][t][p]) % MOD;
}
}
}
int ans = 0;
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++) ans = (ans + dp[l - 1][j][k]) % MOD;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
vector<pair<int, int>> types;
long long dp[3001][100][101] = {0};
int main() {
int n, l;
cin >> n >> l;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
types.push_back({a, b});
}
for (int i = 0; i < n; i++) {
dp[types[i].first][i][types[i].second]++;
if (types[i].first != types[i].second) {
dp[types[i].second][i][types[i].first]++;
}
}
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 (i - types[j].first > 0) {
dp[i][j][types[j].second] +=
dp[i - types[j].first][k][types[j].first];
dp[i][j][types[j].second] %= MOD;
}
if (types[j].first != types[j].second && i - types[j].second > 0) {
dp[i][j][types[j].first] +=
dp[i - types[j].second][k][types[j].second];
dp[i][j][types[j].first] %= MOD;
}
}
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 100; j++) {
ans = (ans + dp[l][i][j]) % MOD;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
cin >> n >> l;
long long count[3010][210];
int length[200], width[200];
for (int i = 0; i < 2 * n; i += 2) {
cin >> length[i] >> width[i];
if (length[i] != width[i]) {
length[i + 1] = width[i];
width[i + 1] = length[i];
} else {
length[i + 1] = -1;
width[i + 1] = -1;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2 * n; ++j) {
count[i][j] = 0;
}
}
for (int j = 0; j < 2 * n; ++j) {
if (length[j] <= l && length[j] > 0) {
count[length[j]][j] = 1;
}
}
for (int i = 1; i <= l; ++i) {
for (int j = 0; j < 2 * n; ++j) {
if (length[j] <= 0) {
continue;
}
int w = width[j];
for (int k = 0; k < 2 * n; ++k) {
if (length[k] == w && k / 2 != j / 2 && i + length[k] <= l) {
count[i + length[k]][k] += count[i][j];
count[i + length[k]][k] %= 1000000007;
}
}
}
}
long long sum = 0;
for (int i = 0; i < 2 * n; ++i) {
sum += count[l][i];
sum %= 1000000007;
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
int dp[4009][201];
int a[201], b[201];
void add(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
int main() {
while (cin >> n >> l) {
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
dp[b[i]][i] = 1;
if (a[i] != b[i]) a[i + n] = b[i], b[i + n] = a[i], dp[a[i]][i + n] = 1;
}
for (int i = 1; i < l; i++)
for (int j = 0; j < n + n; j++) {
if (!dp[i][j]) continue;
for (int k = 0; k < n + n; k++) {
if (k % n == j % n) continue;
if (b[k] == a[j]) add(dp[i + b[k]][k], dp[i][j]);
}
}
int ans = 0;
for (int i = 0; i < n + n; i++) add(ans, dp[l][i]);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf = 1e16;
const long long N = 1e2 + 5;
long long n, l;
long long w[N], h[N];
long long dp[N][N * 30][2];
long long solve(long long lst, long long sum, long long flag) {
if (sum < 0) return 0;
if (sum == 0) {
return 1;
}
long long &ans = dp[lst][sum][flag];
if (ans != -1) return ans;
ans = 0;
for (long long i = 1; i <= n; i++) {
if (i == lst) continue;
long long wid, hei;
if (lst == 0) {
ans += solve(i, sum - h[i], 0);
ans %= 1000000007;
if (w[i] != h[i]) ans += solve(i, sum - w[i], 1);
ans %= 1000000007;
} else {
if (flag == 0) {
wid = w[lst], hei = h[lst];
} else {
wid = h[lst], hei = w[lst];
}
if (h[i] == wid) {
ans += solve(i, sum - h[i], 0);
ans %= 1000000007;
}
if (w[i] == wid and w[i] != h[i]) {
ans += solve(i, sum - w[i], 1);
ans %= 1000000007;
}
}
}
return ans;
}
void solve() {
memset(dp, -1, sizeof dp);
cin >> n >> l;
for (long long i = 1; i <= n; i++) {
cin >> w[i] >> h[i];
}
long long ans = solve(0, l, 0);
cout << ans << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[3333][111][2];
const int MOD = int(1e9 + 7);
int main() {
int n, L;
cin >> n >> L;
vector<int> a(n), b(n);
for (int(i) = (int)(0); (i) < (int)(n); ++(i)) cin >> a[i] >> b[i];
memset(dp, 0, sizeof(dp));
for (int(i) = (int)(0); (i) < (int)(n); ++(i)) {
++dp[a[i]][i][0];
if (a[i] != b[i]) ++dp[b[i]][i][1];
}
for (int l = 0; l <= L; ++l)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (i != j) {
if (a[j] == b[i]) {
dp[l + a[j]][j][0] += dp[l][i][0];
dp[l + a[j]][j][0] %= MOD;
}
if (a[j] == a[i]) {
dp[l + a[j]][j][0] += dp[l][i][1];
dp[l + a[j]][j][0] %= MOD;
}
if (a[j] != b[j] && b[j] == b[i]) {
dp[l + b[j]][j][1] += dp[l][i][0];
dp[l + b[j]][j][1] %= MOD;
}
if (a[j] != b[j] && b[j] == a[i]) {
dp[l + b[j]][j][1] += dp[l][i][1];
dp[l + b[j]][j][1] %= MOD;
}
}
int ans = 0;
for (int(i) = (int)(0); (i) < (int)(n); ++(i)) {
ans += dp[L][i][0];
ans %= MOD;
ans += dp[L][i][1];
ans %= MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
using namespace std;
const int N = 1511;
const int INF = 111111111;
const long long MOD = 1000000007;
const double eps = 1e-9;
const double pi = 3.14159265358979;
long long f[100][3001][2], ans;
int n, a[200], b[200], len;
int main() {
scanf("%d%d", &n, &len);
for (int i = 0; i < (n); i++) scanf("%d%d", &a[i], &b[i]);
for (int i = 1; i <= (len); i++)
for (int last = 0; last < (n); last++) {
if (i - a[last] == 0) f[last][i][0] = 1;
if (i - a[last] > 0)
for (int prev = 0; prev < (n); prev++) {
if (prev != last && b[prev] == a[last])
f[last][i][0] += f[prev][i - a[last]][0];
if (prev != last && a[prev] == a[last])
f[last][i][0] += f[prev][i - a[last]][1];
}
if (a[last] != b[last]) {
if (i - b[last] == 0) f[last][i][1] = 1;
if (i - b[last] > 0)
for (int prev = 0; prev < (n); prev++) {
if (prev != last && b[prev] == b[last])
f[last][i][1] += f[prev][i - b[last]][0];
if (prev != last && a[prev] == b[last])
f[last][i][1] += f[prev][i - b[last]][1];
}
}
f[last][i][0] %= MOD;
f[last][i][1] %= MOD;
}
for (int i = 0; i < (n); i++) ans += f[i][len][0] + f[i][len][1];
printf("%d\n", ans % MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int MOD = INF + 7;
int memo[3000 + 1][100 + 1][100];
int N;
vector<int> a, b;
int solve(int len, int w, int nouse) {
if (len == 0) return 1;
if (len < 0) return 0;
if (memo[len][w][nouse] != -1) return memo[len][w][nouse];
int res = 0;
for (int i = 0; i < N; i++)
if (i != nouse) {
if (a[i] == w)
res = (res + solve(len - b[i], b[i], i)) % MOD;
else if (b[i] == w)
res = (res + solve(len - a[i], a[i], i)) % MOD;
}
memo[len][w][nouse] = res;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
memset(memo, -1, sizeof(memo));
int l;
cin >> N >> l;
a.resize(N);
b.resize(N);
for (int i = 0, _n = N; i < _n; i++) {
cin >> a[i] >> b[i];
}
int res = 0;
for (int i = 0, _n = 100; i < _n; i++)
res = (res + solve(l, i + 1, -1)) % MOD;
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int M = 3209;
const int N = 230;
int n, l, a[N], b[N];
long long dp[M][N];
int main() {
while (scanf("%d%d", &n, &l) != EOF) {
memset(dp, 0, sizeof(dp));
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 < 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;
}
}
}
}
long long ans = 0;
for (int i = 0; i < 2 * n; i++) {
ans = (ans + dp[l][i]) % MOD;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned int a[3010][101][2];
int x[101], y[101];
int main() {
int mod = 1000000007;
int l, m;
cin >> m >> l;
for (int i = 0; i < m; ++i) {
int temp1, temp2;
cin >> temp1 >> temp2;
x[i] = temp1;
y[i] = temp2;
a[temp1][i][0] = a[temp2][i][1] = 1;
if (temp1 == temp2) a[temp2][i][1] = 0;
}
for (int i = 0; i <= l; ++i)
for (int j = 0; j < m; ++j)
for (int k = 0; k < 2; ++k) {
if (!a[i][j][k]) continue;
for (int t = 0; t < m; ++t) {
if (t == j) continue;
if (k == 0) {
if (i + x[t] < 3001 && y[t] == x[j])
a[i + x[t]][t][0] = (a[i + x[t]][t][0] + a[i][j][0]) % mod;
if (i + y[t] < 3001 && x[t] == x[j] && x[t] != y[t])
a[i + y[t]][t][1] = (a[i + y[t]][t][1] + a[i][j][0]) % mod;
} else {
if (i + x[t] < 3001 && y[t] == y[j])
a[i + x[t]][t][0] = (a[i + x[t]][t][0] + a[i][j][1]) % mod;
if (i + y[t] < 3001 && x[t] == y[j] && x[t] != y[t])
a[i + y[t]][t][1] = (a[i + y[t]][t][1] + a[i][j][1]) % mod;
}
}
}
int sum = 0;
for (int i = 0; i < m; ++i) sum = (sum + a[l][i][0] + a[l][i][1]) % mod;
cout << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100 + 10;
const int MAXL = 3000 + 100;
const int INF = 1 << 29;
const long long D = 1000 * 1000 * 1000 + 7;
long long d[MAXL + 100][MAX + 10][2];
int f[MAX + 10][2];
bool mrk[MAX + 10];
int n, l;
void dyn() {
for (int j = 0; j < n; j++)
for (int k = 0; k < 1 + mrk[j]; k++) d[f[j][k]][j][k] = 1;
for (int i = 0; i < l; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++)
for (int jj = 0; jj < n; jj++)
for (int kk = 0; kk < 1 + mrk[jj]; kk++)
if (j != jj && f[jj][kk] == f[j][1 - k]) {
d[i + f[jj][kk]][jj][kk] += d[i][j][k];
if (d[i + f[jj][kk]][jj][kk] > D) d[i + f[jj][kk]][jj][kk] -= D;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> l;
for (int i = 0; i < n; i++)
cin >> f[i][0] >> f[i][1], mrk[i] = (f[i][0] != f[i][1]);
dyn();
long long sum = 0;
for (int i = 0; i < n; i++) sum += d[l][i][0] + d[l][i][1];
sum %= D;
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long d3 = 1000;
const long d4 = 10000;
const long d5 = 100000;
const long d6 = 1000000;
const long d7 = 10000000;
const long d8 = 100000000;
const long d9 = 1000000000;
const long long MOD = d9 + 7;
int main() {
long n, l, a[100], b[100];
long long dp[3501][101][2];
for (int i = 0; i < 3501; i++) {
for (int j = 0; j < 101; j++) {
for (int z = 0; z < 2; z++) {
dp[i][j][z] = 0;
}
}
}
cin >> n >> l;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
long w;
for (int i = 0; i < n; i++) {
dp[b[i]][i][0] = 1;
if (b[i] != a[i]) {
dp[a[i]][i][1] = 1;
}
}
for (int i = 0; i < l; i++) {
for (int j = 0; j < n; j++) {
w = a[j];
for (int z = 0; z < n; z++) {
if (z != j) {
if (b[z] == w) {
dp[i + w][z][0] = (dp[i + w][z][0] + dp[i][j][0]) % MOD;
} else {
if (a[z] == w) {
dp[i + w][z][1] = (dp[i + w][z][1] + dp[i][j][0]) % MOD;
}
}
}
}
w = b[j];
for (int z = 0; z < n; z++) {
if (z != j) {
if (b[z] == w) {
dp[i + w][z][0] = (dp[i + w][z][0] + dp[i][j][1]) % MOD;
} else {
if (a[z] == w) {
dp[i + w][z][1] = (dp[i + w][z][1] + dp[i][j][1]) % MOD;
}
}
}
}
}
}
long long answ = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
answ = (answ + dp[l][i][j]) % MOD;
}
}
cout << answ;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long D[3047][147][2];
int main() {
int n, l;
scanf("%d %d ", &n, &l);
vector<pair<int, int> > A;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d ", &x, &y);
A.push_back(make_pair(x, y));
if (x == y) D[x][i][1]--;
D[y][i][0] += 1;
D[x][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 (j == k) continue;
if (A[j].first != A[j].second) {
if (i - A[j].second >= 0 && A[k].first == A[j].second)
D[i][j][0] += D[i - A[j].second][k][0];
if (i - A[j].second >= 0 && A[k].second == A[j].second)
D[i][j][0] += D[i - A[j].second][k][1];
if (i - A[j].first >= 0 && A[k].first == A[j].first)
D[i][j][1] += D[i - A[j].first][k][0];
if (i - A[j].first >= 0 && A[k].second == A[j].first)
D[i][j][1] += D[i - A[j].first][k][1];
} else {
if (i - A[j].second >= 0 && A[k].first == A[j].second)
D[i][j][0] += D[i - A[j].second][k][0];
if (i - A[j].second >= 0 && A[k].second == A[j].second)
D[i][j][0] += D[i - A[j].second][k][1];
}
D[i][j][0] %= 1000000007;
D[i][j][1] %= 1000000007;
}
}
}
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += D[l][i][0];
sum += D[l][i][1];
sum %= 1000000007;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000 * 1000 * 1000 + 7;
const int maxl = 3000 + 100, maxn = 100 + 10;
long long dp[maxl][maxn][2];
int a[maxn][2];
int main() {
ios_base::sync_with_stdio(false);
int n, first;
cin >> n >> first;
for (int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
for (int l = 1; l <= first; l++)
for (int i = 0; i < n; i++)
for (int p = 0; p < 2 - (a[i][0] == a[i][1]); p++) {
if (l == a[i][p]) {
dp[l][i][p] = 1;
continue;
}
for (int j = 0; j < n; j++)
if (i != j)
for (int q = 0; q < 2 - (a[j][0] == a[j][1]); q++)
if (a[i][p] == a[j][q] && l >= a[i][p]) {
dp[l][i][p] =
(dp[l][i][p] +
dp[l - a[i][p]][j][q ^ (1 & (a[j][0] != a[j][1]))]) %
mod;
}
}
long long res = 0;
for (int i = 0; i < n; i++)
for (int p = 0; p < 2; p++) res = (res + dp[first][i][p]) % mod;
cout << res << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int n, l;
int a[110], b[110];
long long dp[3030][110][2];
long long solve(int len, int prev, int type) {
if (len == 0) {
return 1;
}
long long &it = dp[len][prev][type];
if (it != -1) {
return it;
}
it = 0;
for (int i = 0; i < n; ++i) {
if (prev != i) {
if (type == 0) {
if (a[prev] == b[i] && len >= b[i]) {
it += solve(len - b[i], i, 0);
it %= 1000000007;
}
if (a[i] != b[i] && a[prev] == a[i] && len >= a[i]) {
it += solve(len - a[i], i, 1);
it %= 1000000007;
}
} else {
if (b[prev] == b[i] && len >= b[i]) {
it += solve(len - b[i], i, 0);
it %= 1000000007;
}
if (a[i] != b[i] && b[prev] == a[i] && len >= a[i]) {
it += solve(len - a[i], i, 1);
it %= 1000000007;
}
}
}
}
return it;
}
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) {
scanf("%d%d", a + i, b + i);
}
memset(dp, -1, sizeof(dp));
long long ans = 0;
for (int i = 0; i < n; ++i) {
if (a[i] <= l) {
ans += solve(l - a[i], i, 1);
ans %= 1000000007;
}
if (b[i] <= l && a[i] != b[i]) {
ans += solve(l - b[i], i, 0);
ans %= 1000000007;
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long int N = 200043;
const long long int MOD = 1000000007;
long long int add(long long int x, long long int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
long long int mul(long long int x, long long int y) {
return (x * 1ll * y) % MOD;
}
long long int binpow(long long int x, long long int y) {
long long int z = 1;
while (y) {
if (y & 1) z = mul(z, x);
x = mul(x, x);
y >>= 1;
}
return z;
}
long long int inv(long long int x) { return binpow(x, MOD - 2); }
long long int divide(long long int x, long long int y) {
return mul(x, inv(y));
}
long long int n, l;
vector<pair<long long int, long long int>> v;
long long int dp[101][3][3005];
long long int fun(long long int a, long long int b, long long int c) {
long long int ans = 0, i;
if (c > l) return 0;
if (c == l) return 1;
if (dp[a][b][c] != -1) return dp[a][b][c];
if (b == 0) {
for (i = 0; i < n; i++) {
ans = add(ans, fun(i, 1, c + v[i].second));
if (v[i].second != v[i].first) {
ans = add(ans, fun(i, 2, c + v[i].first));
}
}
} else {
for (i = 0; i < n; i++) {
if (i == a) continue;
if (b == 1 && v[a].second == v[i].first) {
ans = add(ans, fun(i, 1, c + v[i].second));
} else if (b == 1 && v[a].second == v[i].second &&
v[i].first != v[i].second) {
ans = add(ans, fun(i, 2, c + v[i].first));
} else if (b == 2 && v[a].first == v[i].first) {
ans = add(ans, fun(i, 1, c + v[i].second));
} else if (b == 2 && v[a].first == v[i].second &&
v[i].first != v[i].second) {
ans = add(ans, fun(i, 2, c + v[i].first));
}
}
}
dp[a][b][c] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, i, j;
memset(dp, -1, sizeof(dp));
t = 1;
while (t--) {
cin >> n;
cin >> l;
for (i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
v.push_back({a, b});
}
cout << fun(0, 0, 0) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int n, l, a[105], b[105];
int dp[105][3005][2];
int f(int last, int lleft, int ori) {
if (lleft < 0) return 0;
if (lleft == 0) return 1;
int &ret = dp[last][lleft][ori];
if (ret != -1) return ret;
ret = 0;
for (int i = 0; i < n; ++i)
if (i != last) {
if (ori == 0) {
if (a[i] == b[last]) ret = (ret + f(i, lleft - a[i], 0)) % MOD;
if (a[i] != b[i] && b[i] == b[last])
ret = (ret + f(i, lleft - b[i], 1)) % MOD;
} else {
if (a[i] == a[last]) ret = (ret + f(i, lleft - a[i], 0)) % MOD;
if (a[i] != b[i] && b[i] == a[last])
ret = (ret + f(i, lleft - b[i], 1)) % MOD;
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &l);
for (int i = 0; i < n; ++i) scanf("%d%d", &a[i], &b[i]);
memset(dp, -1, sizeof(dp));
int ans = 0;
for (int i = 0; i < n; ++i) {
ans = (ans + f(i, l - a[i], 0)) % MOD;
if (a[i] != b[i]) ans = (ans + f(i, l - b[i], 1)) % MOD;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[3005][105][2];
pair<long long int, long long int> a[105];
long long int n;
long long int func(long long int l, long long int p, bool b) {
if (l < 0) return 0;
if (l == 0) return 1ll;
if (dp[l][p][b] != -1) return dp[l][p][b];
long long int sum = 0, i;
for (i = 1; i <= n; i++) {
if (p == 0) {
sum = (sum + func(l - a[i].first, i, true)) % 1000000007;
if (a[i].second != a[i].first)
sum = (sum + func(l - a[i].second, i, false)) % 1000000007;
} else if (i == p)
continue;
else if (b) {
if (a[i].first == a[p].second)
sum = (sum + func(l - a[i].first, i, true)) % 1000000007;
else if (a[i].second == a[p].second)
sum = (sum + func(l - a[i].second, i, false)) % 1000000007;
} else {
if (a[i].first == a[p].first)
sum = (sum + func(l - a[i].first, i, true)) % 1000000007;
else if (a[i].second == a[p].first)
sum = (sum + func(l - a[i].second, i, false)) % 1000000007;
}
}
dp[l][p][b] = sum;
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int l, i;
memset(dp, -1, sizeof(dp));
cin >> n >> l;
for (i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
cout << func(l, 0, true) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int ni() {
int a;
scanf("%d", &a);
return a;
}
double nf() {
double a;
scanf("%lf", &a);
return a;
}
char sbuf[100005];
string ns() {
scanf("%s", sbuf);
return sbuf;
}
long long nll() {
long long a;
scanf("%lld", &a);
return a;
}
template <class T>
void out(T a, T b) {
bool first = true;
for (T i = a; i != b; ++i) {
if (!first) printf(" ");
first = false;
cout << *i;
}
printf("\n");
}
template <class T>
void outl(T a, T b) {
for (T i = a; i != b; ++i) {
cout << *i << "\n";
}
}
int n, m;
const int mod = 1000000007;
int d[3105][105][3];
int a[105], b[105];
int main() {
int i, j, k;
n = ni();
m = ni();
for (i = (0); i < (((n))); ++i) {
a[i] = ni();
b[i] = ni();
}
for (i = (0); i < (((n))); ++i) {
d[b[i]][i][0] = 1;
if (a[i] != b[i]) d[a[i]][i][1] = 1;
}
int ans = 0;
for (i = (0); i < (((m + 1))); ++i)
for (j = (0); j < (((n))); ++j)
for (k = (0); k < (((2))); ++k)
if (d[i][j][k]) {
if (i == m) (ans += d[i][j][k]) %= mod;
int lastW = (k ? b[j] : a[j]);
int z, zz;
for (z = (0); z < ((n)); ++z)
if (z != j)
for (zz = (0); zz < ((2)); ++zz) {
if (zz == 0 && b[z] == lastW)
(d[i + b[z]][z][zz] += d[i][j][k]) %= mod;
if (zz == 1 && a[z] == lastW && a[z] != b[z])
(d[i + a[z]][z][zz] += d[i][j][k]) %= mod;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
long long dp[3211][101][2];
int n, l;
int a[101], b[101];
int res;
int main() {
ios_base::sync_with_stdio(0);
while (cin >> n >> l) {
for (int i = (0); i < ((n)); ++i) cin >> a[i] >> b[i];
memset(dp, 0, sizeof(dp));
for (int i = (0); i < ((n)); ++i) {
dp[a[i]][i][0] = 1;
if (a[i] != b[i]) dp[b[i]][i][1] = 1;
}
for (int len = (0); len < ((3001)); ++len)
for (int i = (0); i < ((n)); ++i)
for (int j = (0); j < ((n)); ++j)
if (i != j) {
if (a[i] == a[j])
dp[len + a[i] + b[j]][j][1] += dp[len + a[i]][i][0] %= mod;
if (a[j] != b[j] && a[i] == b[j])
dp[len + a[i] + a[j]][j][0] += dp[len + a[i]][i][0] %= mod;
if (b[i] == a[j])
dp[len + b[i] + b[j]][j][1] += dp[len + b[i]][i][1] %= mod;
if (a[j] != b[j] && b[i] == b[j])
dp[len + b[i] + a[j]][j][0] += dp[len + b[i]][i][1] %= mod;
}
long long res = 0;
for (int i = (0); i < ((n)); ++i)
for (int j = (0); j < ((2)); ++j) res += dp[l][i][j] %= mod;
res %= mod;
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 111, maxl = 3333, MOD = 1e9 + 7;
int n, i, j, k, L, jj, kk, an;
long long f[maxl][maxn][4], a[maxn][4];
int main() {
scanf("%d%d", &n, &L);
for (i = 1; i <= n; ++i) scanf("%d%d", &a[i][0], &a[i][1]);
memset(f, 0, sizeof f);
for (i = 1; i <= n; ++i)
f[a[i][0]][i][0] = 1, f[a[i][1]][i][1] = (a[i][0] == a[i][1]) ? 0 : 1;
for (i = 1; i < L; ++i)
for (j = 1; j <= n; ++j)
for (k = 0; k <= 1; ++k) {
for (jj = 1; jj <= n; ++jj) {
if (j == jj) continue;
for (kk = 0; kk <= 1; ++kk) {
if (kk && a[jj][0] == a[jj][1]) continue;
if (a[j][k] != a[jj][kk ^ 1]) continue;
f[i + a[jj][kk]][jj][kk] =
(f[i + a[jj][kk]][jj][kk] + f[i][j][k]) % MOD;
}
}
}
an = 0;
for (i = 1; i <= n; ++i) an = (an + f[L][i][0] + f[L][i][1]) % MOD;
printf("%d\n", an);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
long long binpow(long long base, long long exp, int mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
long long mod(long long x) {
return ((x % 1000000007LL + 1000000007LL) % 1000000007LL);
}
long long add(long long a, long long b) { return mod(mod(a) + mod(b)); }
long long mul(long long a, long long b) { return mod(mod(a) * mod(b)); }
long long int dp[4000 + 1][100][2] = {0};
int main() {
long long int mod = 1000000007;
long long int n, l;
cin >> n >> l;
vector<pair<long long int, long long int>> z;
for (long long int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
z.emplace_back(make_pair(a, b));
}
for (long long int j = 0; j < n; j++) {
if (z[j].second <= l) {
dp[z[j].second][j][0] = 1;
}
if (z[j].first != z[j].second) {
if (z[j].first <= l) {
dp[z[j].first][j][1] = 1;
}
}
}
for (long long int i = 1; i < l + 1; i++) {
for (long long int j = 0; j < n; j++) {
for (long long int p = 0; p < n; p++) {
if (j != p) {
if ((z[j].first == z[p].second) && i > z[j].second)
dp[i][j][0] = (dp[i][j][0] + dp[i - z[j].second][p][0]) % mod;
if ((z[j].first == z[p].first) && i > z[j].second)
dp[i][j][0] = (dp[i][j][0] + dp[i - z[j].second][p][1]) % mod;
if (z[j].first != z[j].second) {
if ((z[j].second == z[p].second) && i > z[j].first)
dp[i][j][1] = (dp[i][j][1] + dp[i - z[j].first][p][0]) % mod;
if ((z[j].second == z[p].first) && i > z[j].first)
dp[i][j][1] = (dp[i][j][1] + dp[i - z[j].first][p][1]) % mod;
} else {
dp[i][j][1] = 0;
}
}
}
}
}
long long int an = 0;
for (long long int j = 0; j < n; j++) {
an = ((an + dp[l][j][0]) % mod + dp[l][j][1]) % mod;
}
cout << an << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, l, a[111], b[111], f[3033][111], s[3033][111];
void read(void) {
cin >> n >> l;
for (long long i = 0; i < n; ++i) cin >> a[i] >> b[i];
for (long long i = 0; i < n; ++i) {
if (a[i] != b[i]) f[0][i] = 1;
s[0][i] = 1;
}
for (long long i = 1; i <= l; ++i)
for (long long j = 0; j < n; ++j) {
f[i][j] = 0;
s[i][j] = 0;
for (long long k = 0; k < n; ++k)
if (k != j) {
if (a[k] == a[j] && i >= b[k]) f[i][j] += s[i - b[k]][k];
if (b[k] == a[j] && i >= a[k] && a[k] != b[k])
f[i][j] += f[i - a[k]][k];
f[i][j] %= 1000000007;
if (a[k] == b[j] && i >= b[k]) s[i][j] += s[i - b[k]][k];
if (b[k] == b[j] && i >= a[k] && a[k] != b[k])
s[i][j] += f[i - a[k]][k];
s[i][j] %= 1000000007;
}
if (a[j] == b[j]) f[i][j] = 0;
}
}
int main() {
long long sum = 0;
read();
for (long long k = 0; k < n; ++k) {
if (l >= b[k]) sum += s[l - b[k]][k];
if (l >= a[k]) sum += f[l - a[k]][k];
sum %= 1000000007;
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void Int(T &a) {
bool minus = false;
a = 0;
char ch = getchar();
while (true) {
if (ch == '-' or (ch >= '0' && ch <= '9')) break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
a = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
a = a * 10 + (ch - '0');
}
if (minus) a *= -1;
}
template <typename T>
inline void Int(T &a, T &b) {
Int(a), Int(b);
}
template <typename T>
inline void Int(T &a, T &b, T &c) {
Int(a, b), Int(c);
}
template <typename T>
inline void Int(T &a, T &b, T &c, T &d) {
Int(a, b), Int(c, d);
}
void err(istream_iterator<string> it) { cout << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ' ';
err(++it, args...);
}
const int N = (int)2e5 + 5;
const int maxN = (int)1e6 + 6;
const long long Mod = (long long)1e9 + 7;
const int inf = (int)2e9;
const long long Inf = (long long)1e18;
const int mod = (int)1e9 + 7;
inline int add(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
inline int sub(int a, int b) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b) { return (long long)a * b % mod; }
int dp[102][3003][2], a[101], b[101], n, m;
int call(bool ok, int board, int len, bool isRotate) {
if (len == m) return 1;
if (len > m) return 0;
int &ret = dp[board][len][isRotate];
if (~ret) return ret;
ret = 0;
for (int i = 1; i <= n; ++i) {
if (i == board) continue;
if (!ok) {
ret = add(ret, call(1, i, len + a[i], 0));
if (a[i] != b[i]) ret = add(ret, call(1, i, len + b[i], 1));
} else {
if (!isRotate) {
if (a[i] == b[board]) ret = add(ret, call(1, i, len + a[i], 0));
if (a[i] != b[i] and b[i] == b[board])
ret = add(ret, call(1, i, len + b[i], 1));
} else {
if (a[i] == a[board]) ret = add(ret, call(1, i, len + a[i], 0));
if (a[i] != b[i] and b[i] == a[board])
ret = add(ret, call(1, i, len + b[i], 1));
}
}
}
return ret;
}
int main() {
int test = 1, tc = 0;
while (test--) {
memset(dp, -1, sizeof dp);
n, m;
Int(n, m);
for (int i = 1; i <= n; ++i) Int(a[i], b[i]);
int res = call(0, 0, 0, 0);
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 3010;
const int N = 110;
const long long md = 1000000007;
long long d[M][N][2];
bool ok[N][N][2][2];
bool can[N][2];
int a[N][2], n, m;
int main() {
int i, j, k;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> a[i][0] >> a[i][1];
memset(ok, false, sizeof(ok));
memset(can, true, sizeof(can));
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++)
if (i != j) {
if (a[i][1] == a[j][0]) ok[i][j][0][0] = true;
if (a[i][1] == a[j][1]) ok[i][j][0][1] = true;
if (a[i][0] == a[j][0]) ok[i][j][1][0] = true;
if (a[i][0] == a[j][1]) ok[i][j][1][1] = true;
}
}
for (i = 1; i <= n; i++)
if (a[i][0] == a[i][1]) can[i][1] = false;
for (i = 1; i <= n; i++) ok[0][i][0][0] = ok[0][i][0][1] = true;
d[0][0][0] = 1;
for (int l = 0; l < m; l++)
for (i = 0; i <= n; i++)
for (int st = 0; st <= 1; st++)
if (d[l][i][st]) {
for (j = 1; j <= n; j++)
for (int tt = 0; tt <= 1; tt++)
if (ok[i][j][st][tt] && l + a[j][tt] <= m && can[j][tt])
d[l + a[j][tt]][j][tt] =
(d[l + a[j][tt]][j][tt] + d[l][i][st]) % md;
}
long long ans = 0;
for (i = 1; i <= n; i++)
for (k = 0; k <= 1; k++)
if (can[i][k]) ans = (ans + d[m][i][k]) % md;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[3001][3010];
int main() {
long long n, l, k = 0;
cin >> n >> l;
long long a[3000], b[3000], c[3000];
for (int i = int(1); i <= int(n); i++) {
cin >> a[i] >> b[i];
c[i] = i;
if (a[i] != b[i]) {
k++;
c[n + k] = i;
a[n + k] = b[i];
b[n + k] = a[i];
}
}
n += k;
long long ans = 0;
for (int i = int(1); i <= int(l); i++) {
for (int j = int(1); j <= int(n); j++) {
if (a[j] == i) dp[i][j] = 1;
for (int last = int(1); last <= int(n); last++) {
if (b[last] == a[j] && i >= a[j] && c[j] != c[last])
dp[i][j] = (dp[i][j] + dp[i - a[j]][last]) % 1000000007;
}
if (i == l) ans = (ans + dp[l][j]) % 1000000007;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
const int MAXL = 3110;
const int MOD = 1000000007;
int n, l, f[MAXL][MAXN][2];
pair<int, int> r[MAXN];
int main() {
std::ios::sync_with_stdio(false);
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> r[i].first >> r[i].second;
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
f[r[i].first][i][0]++;
if (r[i].first != r[i].second) f[r[i].second][i][1]++;
}
for (int i = 0; i < l; i++)
for (int j = 0; j < n; j++)
if (f[i][j][0] || f[i][j][1]) {
for (int k = 0; k < n; k++)
if (k != j) {
if (r[k].first == r[j].second)
f[i + r[k].first][k][0] =
(f[i + r[k].first][k][0] + f[i][j][0]) % MOD;
if (r[k].first == r[j].first)
f[i + r[k].first][k][0] =
(f[i + r[k].first][k][0] + f[i][j][1]) % MOD;
if (r[k].first != r[k].second) {
if (r[k].second == r[j].second)
f[i + r[k].second][k][1] =
(f[i + r[k].second][k][1] + f[i][j][0]) % MOD;
if (r[k].second == r[j].first)
f[i + r[k].second][k][1] =
(f[i + r[k].second][k][1] + f[i][j][1]) % MOD;
}
}
}
int ans = 0;
for (int i = 0; i < n; i++)
ans = (ans + (f[l][i][0] + f[l][i][1]) % MOD) % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mm = 3333;
const int mn = 222;
const int mod = 1000000007;
long long f[mm][mn];
long long g[mm][mn], ans;
int a[mn];
int i, j, k, n, l;
int main() {
while (~scanf("%d%d", &n, &l)) {
for (i = 1; i <= n; ++i) scanf("%d%d", &a[i], &a[n + i]);
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
for (j = 1; j <= 2 * n; ++j) g[0][a[j]] = 1;
for (i = 1; i <= l; ++i)
for (j = 1; j <= 2 * n; ++j)
if (a[j] <= i)
if (j <= n) {
f[i][j] += g[i - a[j]][a[j]];
if (a[j + n] == a[j]) f[i][j] -= f[i - a[j]][j];
f[i][j] -= f[i - a[j]][j + n];
if (f[i][j] < 0) f[i][j] += mod;
f[i][j] %= mod;
g[i][a[j + n]] += f[i][j];
g[i][a[j + n]] %= mod;
} else if (a[j - n] != a[j]) {
f[i][j] += g[i - a[j]][a[j]];
if (a[j - n] == a[j]) f[i][j] -= f[i - a[j]][j];
f[i][j] -= f[i - a[j]][j - n];
if (f[i][j] < 0) f[i][j] += mod;
f[i][j] %= mod;
g[i][a[j - n]] += f[i][j];
g[i][a[j - n]] %= mod;
}
ans = 0;
for (i = 1; i <= 2 * n; ++i) {
ans += f[l][i];
ans %= mod;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
int wid[100];
int len[100];
long long dp[3001][100][2];
vector<int> adj[100][2];
vector<int> orient[100][2];
long long ways(int l, int i, int x) {
long long ret = 0;
for (int k = 0; k < adj[i][x].size(); k++) {
int j = adj[i][x][k];
int o = orient[i][x][k];
if (x == 0 and l >= len[i]) {
ret = (ret + dp[l - len[i]][j][o]) % MOD;
} else if (x == 1 and l >= wid[i]) {
ret = (ret + dp[l - wid[i]][j][o]) % MOD;
}
}
return ret;
}
int main() {
int maxl, n;
cin >> n >> maxl;
for (int i = 0; i < n; i++) {
cin >> len[i] >> wid[i];
}
if (n == 1) {
if (len[0] == maxl or wid[0] == maxl)
cout << "1\n";
else
cout << "0\n";
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (wid[i] == len[j]) {
adj[i][0].push_back(j);
orient[i][0].push_back(0);
} else if (wid[i] == wid[j]) {
adj[i][0].push_back(j);
orient[i][0].push_back(1);
}
if (len[i] == len[j]) {
adj[i][1].push_back(j);
orient[i][1].push_back(0);
} else if (len[i] == wid[j]) {
adj[i][1].push_back(j);
orient[i][1].push_back(1);
}
}
}
for (int i = 0; i < n; i++) {
for (int x = 0; x < 2; x++) dp[0][i][x] = 1;
}
for (int l = 1; l <= maxl; l++) {
for (int i = 0; i < n; i++) {
long long u, v;
if (len[i] == l)
u = 1;
else
u = ways(l, i, 0);
if (wid[i] == l)
v = 1;
else
v = ways(l, i, 1);
dp[l][i][0] = u;
dp[l][i][1] = v;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + dp[maxl][i][0]) % MOD;
if (len[i] != wid[i]) ans = (ans + dp[maxl][i][1]) % MOD;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int m = 1e9 + 7;
vector<vector<int>> x(101);
int seq = 0;
int main() {
int n, l, i, a, b;
cin >> n >> l;
array<int, 2> size[n + 1];
int dp[3001][101][2] = {0};
for (i = 1; i <= n; i++) {
cin >> a >> b;
size[i][0] = a;
size[i][1] = b;
x[a].push_back(i);
if (b != a) x[b].push_back(i);
}
int len;
for (len = 1; len <= l; len++) {
for (i = 1; i <= n; i++) {
a = size[i][0];
b = size[i][1];
if (a == len)
dp[len][i][0] = 1;
else if (a < len) {
for (int j : x[a]) {
if (j == i) continue;
if (size[j][0] == size[j][1])
dp[len][i][0] = (dp[len][i][0] + dp[len - a][j][0]) % m;
else if (a == size[j][0])
dp[len][i][0] = (dp[len][i][0] + dp[len - a][j][1]) % m;
else
dp[len][i][0] = (dp[len][i][0] + dp[len - a][j][0]) % m;
}
}
if (b == a) continue;
if (b == len)
dp[len][i][1] = 1;
else if (b < len) {
for (int j : x[b]) {
if (j == i) continue;
if (size[j][0] == size[j][1])
dp[len][i][1] = (dp[len][i][1] + dp[len - b][j][0]) % m;
else if (b == size[j][0])
dp[len][i][1] = (dp[len][i][1] + dp[len - b][j][1]) % m;
else
dp[len][i][1] = (dp[len][i][1] + dp[len - b][j][0]) % m;
}
}
}
}
long long int ans = 0, add;
for (i = 1; i <= n; i++) {
add = (dp[l][i][0] + dp[l][i][1]) % m;
ans = (ans + add) % m;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int g[210][210], n, n2, m;
long long dp[3111][205];
struct edge {
int x, y, ty;
} a[210];
int main() {
scanf("%d%d", &n, &m);
n2 = n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i].ty = i;
if (a[i].x != a[i].y) {
a[++n2].x = a[i].y;
a[n2].y = a[i].x;
a[n2].ty = i;
}
}
n = n2;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (a[i].ty == a[j].ty) continue;
if (a[i].y == a[j].x) g[i][j] = 1;
}
for (int i = 1; i <= n; i++) dp[a[i].x][i] = 1;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
if (!dp[i][j]) continue;
for (int k = 1; k <= n; k++) {
if (j == k) continue;
if (g[j][k]) {
dp[i + a[k].x][k] = (dp[i + a[k].x][k] + dp[i][j]) % MOD;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans = (ans + dp[m][i]) % MOD;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l, n, ans, a[100 + 5], b[100 + 5], vis[3000 + 5][100 + 5][5],
memo[3000 + 5][100 + 5][5];
int dp(int now, int last, int state) {
if (now == l) return 1;
if (now > l) return 0;
if (memo[now][last][state] > -1) return memo[now][last][state];
int i, k, ret = 0;
if (!state)
k = b[last];
else
k = a[last];
for (i = 0; i < n; i++) {
if (i == last) continue;
if (k == a[i]) ret = (ret + dp(now + a[i], i, 0)) % 1000000007;
if (k == b[i] && a[i] != b[i])
ret = (ret + dp(now + b[i], i, 1)) % 1000000007;
}
memo[now][last][state] = ret;
return ret;
}
int main() {
int i;
memset(memo, -1, sizeof(memo));
scanf("%d %d", &n, &l);
for (i = 0; i < n; i++) scanf("%d %d", &a[i], &b[i]);
for (i = 0; i < n; i++) {
if (a[i] != b[i])
ans =
(((ans + dp(a[i], i, 0)) % 1000000007) + dp(b[i], i, 1)) % 1000000007;
else
ans = (ans + dp(a[i], i, 0)) % 1000000007;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int MaxL = 4000;
const int MaxN = 300;
int f[MaxL][MaxN];
int ans = 0, n, l, a[MaxN], b[MaxN], nom[MaxN], m;
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
m++;
cin >> a[m] >> b[m];
nom[m] = i;
if (a[m] == b[m]) continue;
m++;
a[m] = b[m - 1];
b[m] = a[m - 1];
nom[m] = i;
}
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (int i = 0; i <= l; i++)
for (int j = 0; j <= m; j++)
if (f[i][j] != 0) {
for (int k = 1; k <= m; k++)
if (nom[k] != nom[j] && b[j] == a[k]) {
f[i + a[k]][k] = (f[i + a[k]][k] + f[i][j]) % mod;
} else if (j == 0) {
f[i + a[k]][k] = (f[i + a[k]][k] + f[i][j]) % mod;
}
}
for (int i = 0; i <= m; i++) ans = (ans + f[l][i]) % mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
typedef struct {
int a, b, z;
} ele;
ele g[300];
int nn;
int dp[200][4000] = {0};
int main() {
int n, l, i, j, k;
scanf("%d %d", &n, &l);
nn = 0;
for (i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
g[nn++] = (ele){x, y, i};
if (x != y) g[nn++] = (ele){y, x, i};
}
for (i = 0; i < nn; i++) dp[i][g[i].a] = 1;
for (k = 1; k <= l; k++) {
for (i = 0; i < nn; i++) {
for (j = 0; j < nn; j++) {
if (g[j].z == g[i].z) continue;
if (g[i].a == g[j].b && k - g[i].a >= 0)
dp[i][k] = (dp[i][k] + dp[j][k - g[i].a]) % 1000000007;
}
}
}
int ans = 0;
for (i = 0; i < nn; i++) ans = (ans + dp[i][l]) % 1000000007;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int infinity = 9e18;
long long int dp[3001][101][101] = {};
void print2d(long long int l, long long int n) {
for (int i = 1; i <= l; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < 10; k++) {
cout << dp[i][j][k] << " ";
}
cout << "\n";
}
cout << "\n"
<< "\n";
}
cout << "\n";
cout << "\n";
cout << "\n";
cout << "\n";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, l;
cin >> n >> l;
vector<pair<long long int, long long int> > vp(n);
for (int i = 0; i < n; i++) {
cin >> vp[i].first >> vp[i].second;
}
for (int i = 0; i < n; i++) {
if (vp[i].first == vp[i].second) {
if (vp[i].first <= l) {
dp[vp[i].first][i][vp[i].first]++;
}
} else {
if (vp[i].first <= l) dp[vp[i].first][i][vp[i].second]++;
if (vp[i].second <= l) dp[vp[i].second][i][vp[i].first]++;
}
}
for (int i = 2; i <= l; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (k == j) continue;
if (vp[j].first == vp[j].second) {
if (i > (vp[j].first))
dp[i][j][vp[j].second] =
(dp[i][j][vp[j].second] + dp[i - vp[j].first][k][vp[j].first]) %
1000000007;
} else {
if (i > (vp[j].first)) {
dp[i][j][vp[j].second] =
(dp[i][j][vp[j].second] + dp[i - vp[j].first][k][vp[j].first]) %
1000000007;
}
if (i > (vp[j].second)) {
dp[i][j][vp[j].first] = (dp[i][j][vp[j].first] +
dp[i - vp[j].second][k][vp[j].second]) %
1000000007;
}
}
}
}
}
long long int total = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 101; j++) {
total = (total + dp[l][i][j]) % 1000000007;
}
}
cout << total;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, l;
int a[101][2];
long long F[101][3001][2];
long long ans = 0;
long long dp(int i, int len, int j) {
if (len <= 0) return 0;
if (F[i][len][j] != -1) {
return F[i][len][j];
}
long long ans = 0;
for (int ij = 0; ij <= 1; ij++) {
for (int ii = 1; ii <= i - 1; ii++)
if (a[i][j] == a[ii][(!ij)]) {
if (ij == 1 && a[ii][1] == a[ii][0]) continue;
ans += dp(ii, len - a[i][j], ij);
ans %= 1000000007;
}
for (int ii = i + 1; ii <= n; ii++)
if (a[i][j] == a[ii][(!ij)]) {
if (ij == 1 && a[ii][1] == a[ii][0]) continue;
ans += dp(ii, len - a[i][j], ij);
ans %= 1000000007;
}
}
return F[i][len][j] = ans;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t start = clock();
cin >> n >> l;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 1; j++) {
for (int k = 1; k <= l; k++) F[i][k][j] = -1;
cin >> a[i][j];
F[i][a[i][j]][j] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 1; j++) {
if (j == 1 && a[i][0] == a[i][1]) continue;
ans += dp(i, l, j);
ans %= 1000000007;
}
cout << ans << '\n';
cerr << "Time: " << (double)(clock() - start) / CLOCKS_PER_SEC << "s\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:16777216")
int n, L, a[110], b[110];
const int MODULO = 1000000007;
int dp[3010][110][2];
int f(int l, int last, bool turned) {
if (l < 0) return 0;
if (l == 0) return 1;
if (dp[l][last][turned] >= 0) return dp[l][last][turned];
int need = turned ? b[last] : a[last];
int ans = 0;
for (int i = 0; (i) < (n); ++(i)) {
if (i == last) continue;
if (b[i] == need) {
ans += f(l - b[i], i, false);
if (ans >= MODULO) ans -= MODULO;
}
if (a[i] == need && a[i] != b[i]) {
ans += f(l - a[i], i, true);
if (ans >= MODULO) ans -= MODULO;
}
}
return dp[l][last][turned] = ans;
}
int main() {
scanf("%d%d", &n, &L);
for (int i = 0; (i) < (n); ++(i)) scanf("%d%d", &a[i], &b[i]);
memset((dp), -1, sizeof((dp)));
int sum = 0;
for (int i = 0; (i) < (n); ++(i)) {
sum += f(L - b[i], i, false);
if (sum >= MODULO) sum -= MODULO;
if (a[i] != b[i]) {
sum += f(L - a[i], i, true);
if (sum >= MODULO) sum -= MODULO;
}
}
printf("%d\n", sum);
return 0;
}
|
#include <bits/stdc++.h>
const int M = 1000000000 + 7;
int n, l, a[2][100];
int dp[30001][100][2], res = 0;
int main() {
scanf("%d %d", &n, &l);
for (int i = 0; i < n; ++i) scanf("%d %d", &a[0][i], &a[1][i]);
for (int i = 1; i <= l; ++i)
for (int k = 0; k < n; ++k)
for (int p = 0, P = a[0][k] == a[1][k] ? 1 : 2; p < P; ++p)
if (i == a[p][k])
dp[i][k][p] = 1;
else if (i > a[p][k]) {
dp[i][k][p] = 0;
for (int j = 0; j < n; ++j)
if (k != j)
for (int q = 0; q < 2; ++q)
if (a[(q + 1) % 2][j] == a[p][k])
dp[i][k][p] = (dp[i][k][p] + dp[i - a[p][k]][j][q]) % M;
}
for (int i = 0; i < n; ++i) res = (res + (dp[l][i][0] + dp[l][i][1]) % M) % M;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, l;
long long aa[128], bb[128];
long long dp[3008][128][2];
int main() {
cin >> n >> l;
for (long long i = 1; i <= n; i++) cin >> aa[i] >> bb[i];
memset(dp, 0, sizeof dp);
for (long long len = 1; len <= l; len++) {
for (long long k = 1; k <= n; k++) {
long long a = aa[k];
long long b = bb[k];
if (len - a >= 0) {
if (len - a == 0) {
dp[len][k][0] += 1;
}
long long &ref = dp[len][k][0];
for (long long i = 1; i <= n; i++) {
if (i == k) continue;
if (a == bb[i]) {
ref += dp[len - a][i][0];
ref %= 1000000007;
}
if (a == aa[i] && aa[i] != bb[i]) {
ref += dp[len - a][i][1];
ref %= 1000000007;
}
}
}
if (a == b) {
dp[len][k][1] = dp[len][k][0];
continue;
}
if (len - b >= 0) {
if (len - b == 0) {
dp[len][k][1] += 1;
}
long long &ref = dp[len][k][1];
for (long long i = 1; i <= n; i++) {
if (i == k) continue;
if (b == bb[i]) {
ref += dp[len - b][i][0];
ref %= 1000000007;
}
if (b == aa[i] && aa[i] != bb[i]) {
ref += dp[len - b][i][1];
ref %= 1000000007;
}
}
}
}
}
long long res = 0;
for (long long i = 1; i <= n; i++) {
res += dp[l][i][0];
res %= 1000000007;
if (aa[i] != bb[i]) {
res += dp[l][i][1];
res %= 1000000007;
}
}
cout << res % 1000000007 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 9;
int t, id, n, m, x, y, k, c, xx, yy, ans, p;
vector<pair<int, int>> v, adj[N];
bool fl, ok;
long long res, sum[N], cu[N];
char ch;
string s, z;
int L;
long long mem[103][3003][3];
pair<int, int> a[102];
long long dp(int last = n, int rem = L, int preL = 0) {
if (rem < 0) return 0;
if (!rem) return 1;
long long& ret = mem[last][rem][preL];
if (~ret) return ret;
ret = 0;
for (int i = 0; i < (int)n; ++i) {
if (i == last) continue;
if (!preL) {
ret += dp(i, rem - a[i].first, 1), ret %= 1000000007;
if (a[i].first == a[i].second) continue;
ret += dp(i, rem - a[i].second, 2), ret %= 1000000007;
}
if (preL == 1) {
if (a[i].first == a[last].second)
ret += dp(i, rem - a[i].first, 1), ret %= 1000000007;
if (a[i].first == a[i].second) continue;
if (a[i].second == a[last].second)
ret += dp(i, rem - a[i].second, 2), ret %= 1000000007;
} else {
if (a[i].first == a[last].first)
ret += dp(i, rem - a[i].first, 1), ret %= 1000000007;
if (a[i].first == a[i].second) continue;
if (a[i].second == a[last].first)
ret += dp(i, rem - a[i].second, 2), ret %= 1000000007;
}
}
return ret;
}
int main() {
memset(mem, -1, sizeof mem);
;
scanf("%d%d", &n, &L);
for (int i = 0; i < (int)n; ++i) scanf("%d%d", &a[i].first, &a[i].second);
printf("%lld\n", dp());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
int n, len;
int arr[105][2];
int dp[3005][105][2];
inline int rec(int pos, int prev, int prevor) {
if (pos == 0) return 1;
int &ret = dp[pos][prev][prevor];
if (ret != -1) return ret;
ret = 0;
for (int i = 1; i <= n; i++) {
if (i == prev) continue;
for (int j = 0; j < 2; j++) {
if (arr[i][0] == arr[i][1] && j == 1) continue;
if (pos >= arr[i][1 - j] && arr[i][j] == arr[prev][prevor]) {
ret += rec(pos - arr[i][1 - j], i, 1 - j);
ret %= MOD;
}
}
}
return ret;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d %d", &n, &len);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 2; j++) {
scanf("%d", &arr[i][j]);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (len >= arr[i][0]) ans += rec(len - arr[i][0], i, 0);
ans %= MOD;
if (arr[i][0] != arr[i][1]) {
if (len >= arr[i][1]) ans += rec(len - arr[i][1], i, 1);
ans %= MOD;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int n;
int a[(100 + 10)], b[(100 + 10)];
int dp[3000 + 1][100 + 1][100 + 2];
int f(int len, int w, int pre) {
if (len < 0) return 0;
if (len == 0) return 1;
int& ans = dp[len][w][pre];
if (~ans) return ans;
ans = 0;
for (int i(0), _n(n); i < _n; ++i)
if (i != pre) {
if (a[i] == w)
ans = (ans + f(len - b[i], b[i], i)) % MOD;
else if (b[i] == w)
ans = (ans + f(len - a[i], a[i], i)) % MOD;
}
return ans;
}
int main() {
memset((dp), -1, sizeof(dp));
int l;
scanf("%d", &(n)), scanf("%d", &(l));
for (int i(0), _n(n); i < _n; ++i) scanf("%d", &(a[i])), scanf("%d", &(b[i]));
long long ans = 0;
for (int w(1), _h(100); w <= _h; ++w) ans = (ans + f(l, w, 101)) % MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 5, M = 3e3 + 5, MOD = 1e9 + 7;
int n, m, ans;
int a[N << 1], b[N << 1], f[M + 100][N << 1];
int main() {
scanf("%d%d", &n, &m);
for (register int i = 0; i < n; ++i) {
scanf("%d%d", &a[i], &b[i]);
f[a[i]][i] = 1;
if (a[i] != b[i]) {
a[i + n] = b[i];
b[i + n] = a[i];
f[a[i + n]][i + n] = 1;
}
}
for (register int k = 1; k <= m; ++k)
for (register int i = 0; i < n << 1; ++i)
for (register int j = 0; j < n << 1; ++j)
if (i % n != j % n) {
if (a[i] == b[j]) f[k + a[i]][i] = (f[k + a[i]][i] + f[k][j]) % MOD;
}
for (register int i = 0; i < n << 1; ++i) ans = (ans + f[m][i]) % MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1000000007;
int n, l, a[110], b[110];
int i, j, k;
int ans[3010][110][2], out;
int main() {
scanf("%d%d", &n, &l);
for (i = 0; i < n; i++) scanf("%d%d", &a[i], &b[i]);
memset(ans, 0, sizeof(ans));
for (i = 0; i < n; i++) {
ans[b[i]][i][0] = 1;
if (a[i] != b[i]) ans[a[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) continue;
if (a[k] == b[j]) {
if (i >= b[j] + b[k]) {
ans[i][j][0] += ans[i - b[j]][k][0];
ans[i][j][0] %= mod;
}
}
if (b[k] == b[j]) {
if (i >= b[j] + a[k]) {
ans[i][j][0] += ans[i - b[j]][k][1];
ans[i][j][0] %= mod;
}
}
if (a[j] == b[j]) continue;
if (a[k] == a[j]) {
if (i >= a[j] + b[k]) {
ans[i][j][1] += ans[i - a[j]][k][0];
ans[i][j][1] %= mod;
}
}
if (b[k] == a[j]) {
if (i >= a[j] + a[k]) {
ans[i][j][1] += ans[i - a[j]][k][1];
ans[i][j][1] %= mod;
}
}
}
}
}
out = 0;
for (i = 0; i < n; i++)
for (j = 0; j < 2; j++) out = (out + ans[l][i][j]) % mod;
printf("%d\n", out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, w, e, r, t = 0, c, *a[200], s[200], d[200], f[200], p = 1000000007;
cin >> q >> w;
for (e = 0; e < 200; e++) {
a[e] = new int[3001];
for (r = 0; r <= w; r++) a[e][r] = 0;
}
for (; q; q--) {
cin >> e >> r;
s[t] = e;
d[t] = r;
f[t] = q;
a[t][r]++;
t++;
if (e != r) {
s[t] = r;
d[t] = e;
f[t] = q;
a[t][e]++;
t++;
}
}
for (r = 0; r < w; r++)
for (e = 0; e < t; e++)
for (c = 0; c < t; c++)
if ((f[e] != f[c]) && ((d[e] == s[c]) && (r + d[c] <= w))) {
a[c][r + d[c]] += a[e][r];
if (a[c][r + d[c]] >= p) a[c][r + d[c]] -= p;
}
r = 0;
for (e = 0; e < t; e++) {
r += a[e][w];
if (r >= p) r -= p;
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int n, L;
int a[1 << 7], b[1 << 7];
int sum(int a, int b) {
a += b;
while (a >= 1000000007) a -= 1000000007;
return a;
}
int mem[1 << 7][1 << 1][1 << 12];
int get(int deskId, int sw, int len) {
int w = a[deskId];
int h = b[deskId];
if (sw) swap(w, h);
int remLen = len - w;
if (remLen < 0) return 0;
if (remLen == 0) return 1;
int& res = mem[deskId][sw][len];
if (res == -1) {
res = 0;
for (int i = 0; i < (int)(n); ++i) {
if (i == deskId) continue;
if (a[i] == b[i]) {
if (a[i] == h) res = sum(res, get(i, 0, remLen));
} else {
if (a[i] == h) res = sum(res, get(i, 0, remLen));
if (b[i] == h) res = sum(res, get(i, 1, remLen));
}
}
}
return res;
}
int main() {
memset(mem, -1, sizeof(mem));
cin >> n >> L;
for (int i = 0; i < (int)(n); ++i) cin >> a[i] >> b[i];
int res = 0;
for (int i = 0; i < (int)(n); ++i) {
res = sum(res, get(i, 0, L));
if (a[i] != b[i]) {
res = sum(res, get(i, 1, L));
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, l, a[205][5], dp[3005][105][105];
long long MOD = 1000000007;
long long DP(long long len, long long type, long long sizee) {
if (len > l) return 0;
if (len == l) return 1;
long long &cur = dp[len][type][sizee];
if (cur != -1) return cur;
cur = 0;
for (int i = 0; i < n; i++) {
if (type != i) {
if (a[i][0] == sizee) {
cur += DP(len + a[i][0], i, a[i][1]);
cur %= MOD;
}
if (a[i][0] == a[i][1]) continue;
if (a[i][1] == sizee) {
cur += DP(len + a[i][1], i, a[i][0]);
cur %= MOD;
}
}
}
return cur % MOD;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> l;
for (int i = 0; i < n; i++) cin >> a[i][0] >> a[i][1];
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += DP(a[i][0], i, a[i][1]);
ans %= MOD;
if (a[i][0] == a[i][1]) continue;
ans += DP(a[i][1], i, a[i][0]);
ans %= MOD;
}
ans %= MOD;
cout << ans % MOD;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.