text stringlengths 49 983k |
|---|
#include<map>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#define LL long long
using namespace std;
const LL mod=1e9+7;
LL f[110][110][2],n,h[110];
bool vis[110][110];
LL Pow(LL a,LL b)
{
LL ans=1;
while(b)
{
if(b&1) ans=ans*a%mod;
a=a*a%mod;b>>=1;
}
return ans;
}
void solve(LL l,LL r,LL s)
{
//printf("solve:%lld %lld %lld\n",l,r,s);
bool flag=true;
for(LL i=l;i<r;i++) if(h[i]!=h[i+1]) flag=false;
if(flag)
{
LL c=Pow(2,r-l+1);
f[l][r][1]=(c-2+mod)%mod;
f[l][r][0]=Pow(2,h[l]-s+1);
//printf("f:%lld %lld\n",f[l][r][0],f[l][r][1]);
return;
}
LL t=1e9+10,cnt=0;
for(LL i=l;i<=r;i++)
{
if(h[i]<t) t=h[i],cnt=0;
if(t==h[i]) cnt++;
}
LL p=l,g0=2,g1=1;
//printf("t:%lld\n",t);
while(p<=r)
{
while(p<=r&&h[p]==t) p++;
LL q=p;
while(q<=r&&h[q]!=t) q++;
if(p<=r)
{
solve(p,q-1,t+1);
(g0*=f[p][q-1][0])%=mod;
(g1*=(f[p][q-1][0]*2+f[p][q-1][1])%mod)%=mod;
}
//printf("g0 g1:%lld %lld\n",g0,g1);
p=q;
}
//printf("g1:%lld\n",g1);
(g1*=Pow(2,cnt))%=mod;g1-=g0;(g1+=mod)%=mod;
(g0*=Pow(2,t-s))%=mod;
//printf("now:%lld %lld %lld %lld %lld\n",l,r,s,g0,g1);
f[l][r][0]=g0;f[l][r][1]=g1;
}
int main()
{
scanf("%lld",&n);
for(LL i=1;i<=n;i++) scanf("%lld",&h[i]);
memset(vis,false,sizeof(vis));
LL tot=1;
for(LL i=1;i<=n;i++) if(h[i]>h[i-1]&&h[i]>h[i+1])
{
LL t=max(h[i-1],h[i+1]);
(tot*=Pow(2,h[i]-t))%=mod;h[i]=t;
}
solve(1,n,1);
printf("%lld",tot*(f[1][n][0]+f[1][n][1])%mod);
} |
#include<bits/stdc++.h>
const int N=103,M=1e9+7;
using namespace std;
int n,m,a[N],b[N],f[N][N],i,j,tp;
inline int ksm(int t){
if(t<0)return 1;
int y=1;long long x=2;
for(;t;t>>=1)
t&1?y=y*x%M:0,x=x*x%M;
return y;
}
inline void trans(int d){
d=min(d,a[i+1]);
f[i+1][d]=(f[i+1][d]+
1ll*ksm(b[a[i]]-b[max(j,a[i+1])])*tp)%M;
}
int main(){
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d",a+i),b[i]=--a[i];
sort(b,b+n+1),m=unique(b,b+n+1)-b;
for(i=0;i<n;i++)
a[i]=lower_bound(b,b+m,a[i])-b;
f[0][0]=1;
for(i=0;i<n;i++)
for(j=0;j<=a[i];j++)
if(tp=f[i][j])
trans(j),trans(a[i]);
printf("%d",f[n][0]);
} |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int N=110,Mo=1000000007;
int f[N][N],a[N],v[N];
inline int gi() {
int x=0,o=1;
char ch=getchar();
while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
if(ch=='-') o=-1,ch=getchar();
while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
return x*o;
}
inline int Pow(int x,int y) {
int ret=1;
while(y) {
if(y&1) ret=1LL*ret*x%Mo;
x=1LL*x*x%Mo,y>>=1;
}
return ret;
}
int main() {
int n,k,ans=0;
cin>>n;
for(int i=1;i<=n;i++) a[i]=v[i]=gi();
sort(v+1,v+1+n);
k=unique(v+1,v+1+n)-v-1;
for(int i=1;i<=n;i++) a[i]=lower_bound(v+1,v+1+k,a[i])-v;
f[0][0]=1;
for(int i=1;i<=n;i++) {
f[i][0]=2LL*f[i-1][0]%Mo;
for(int j=a[i]+1;j<=a[i-1];j++)
f[i][0]=(f[i][0]+2LL*f[i-1][j])%Mo;
int t=(a[i]<=a[i-1]?1:Pow(2,v[a[i]]-v[a[i-1]]));
for(int j=min(a[i],a[i-1]);j;j--)
f[i][j]=1LL*t*f[i-1][j]%Mo;
for(int j=a[i-1]+1;j<=a[i];j++) {
int t=(j==1?Pow(2,v[j])-2:Pow(2,v[j]-v[j-1]+1)-2);
f[i][j]=(f[i][j]+1LL*f[i-1][0]*t%Mo*Pow(2,v[a[i]]-v[j]))%Mo;
}
}
for(int i=0;i<=k;i++) ans=(ans+f[n][i])%Mo;
cout<<ans;
return 0;
} |
#include <bits/stdc++.h>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define for1(a,b,i) for(int i=a;i<=b;++i)
#define FOR2(a,b,i) for(int i=a;i>=b;--i)
using namespace std;
typedef long long ll;
inline int read() {
int f=1,sum=0;
char x=getchar();
for(;(x<'0'||x>'9');x=getchar()) if(x=='-') f=-1;
for(;x>='0'&&x<='9';x=getchar()) sum=sum*10+x-'0';
return f*sum;
}
#define M 105
#define mod 1000000007
int n;
int a[M];
int tot,st[M],dui[M],f[M][M];
inline int qpow(int x,int ci) {
int sum=1;
for(;ci;ci>>=1,x=1ll*x*x%mod)
if(ci&1) sum=1ll*x*sum%mod;
return sum;
}
inline void inc(int &x,int y){x+=y,x-=x>=mod?mod:0;}
int main() {
//freopen("a.in","r",stdin);
n=read();
for1(1,n,i) {
a[i]=read();
dui[i]=a[i]-1;
}
sort(dui+1,dui+n+1);
for1(1,n,i) {
if(dui[i]!=dui[i-1]) ++tot;
st[tot]=dui[i];
}
for1(1,n,i) {
if(a[i]==1) a[i]=0;
else for1(1,tot,j) if(a[i]==st[j]+1) a[i]=j;
}
f[1][0]=2;
for1(1,a[1],i) f[1][i]=1ll*(qpow(2,st[i]-st[i-1])-1)*qpow(2,st[a[1]]-st[i]+1)%mod;
//for1(0,a[1],i) cout<<f[1][i]<<" "; cout<<endl;
for1(2,n,i) {
for1(1,tot,j) {
if(!f[i-1][j]) continue;
if(j<=a[i]) {
int k=1;
if(a[i]>a[i-1]) k=qpow(2,st[a[i]]-st[a[i-1]]);
inc(f[i][j],1ll*k*f[i-1][j]%mod);
}
else {
inc(f[i][0],2ll*f[i-1][j]%mod);
}
}
inc(f[i][0],2ll*f[i-1][0]%mod);
if(a[i]>a[i-1]) {
for1(a[i-1]+1,a[i],j) {
inc(f[i][j],1ll*f[i-1][0]*(qpow(2,st[j]-st[j-1])-1)%mod*qpow(2,st[a[i]]-st[j]+1)%mod);
}
}
}
//for1(0,a[n],i) cout<<f[n][i]<<" "; cout<<endl;
int ans=0;
for1(0,tot,i) inc(ans,f[n][i]);
cout<<ans<<endl;
} |
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define ll long long
#define inf 0x3f3f3f3f
#define mod 1000000007
#define maxn 200010
inline ll read()
{
ll x=0; char c=getchar(),f=1;
for(;c<'0'||'9'<c;c=getchar())if(c=='-')f=-1;
for(;'0'<=c&&c<='9';c=getchar())x=x*10+c-'0';
return x*f;
}
inline void write(ll x)
{
static char buf[20];
int len=0;
if(x<0)putchar('-'),x=-x;
for(;x;x/=10)buf[len++]=x%10+'0';
if(!len)putchar('0');
else while(len)putchar(buf[--len]);
}
inline void writesp(ll x){write(x); putchar(' ');}
inline void writeln(ll x){write(x); putchar('\n');}
int a[maxn];
int n;
ll power(ll a,ll b)
{
ll ans=1;
for(;b;b>>=1,a=a*a%mod)
if(b&1)ans=ans*a%mod;
return ans;
}
void solve(int l,int r,ll& f,ll& g)
{
int mn=a[l],mx=a[l];
for(int i=l+1;i<=r;i++){
mx=std::max(mx,a[i]);
mn=std::min(mn,a[i]);
}
for(int i=l;i<=r;i++)
a[i]-=mn;
if(mx==mn){
f=(power(2,r-l+1)+mod-2)%mod;
g=power(2,mn);
return;
}
ll mul1=1,mul2=1;
int last=l,cnt=0;
for(int i=l;i<=r;i++)
if(a[i]&&(!a[i+1]||i==r)){
ll tf=0,tg=0;
solve(last,i,tf,tg);
mul1=mul1*(tf+2*tg)%mod;
mul2=mul2*tg%mod;
}
else if(!a[i]){
last=i+1;
++cnt;
}
f=(power(2,cnt)*mul1-2*mul2+2*mod)%mod;
g=power(2,mn)*mul2%mod;
}
int main()
{
n=read();
for(int i=1;i<=n;i++)
a[i]=read();
ll f=0,g=0;
solve(1,n,f,g);
writeln((f+g)%mod);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = a; i <= b; i++)
#define per(i, a, b) for(int i = a; i >= b; i--)
typedef long long LL;
const int maxn = 105;
const LL mod = 1e9 + 7;
int n, h[maxn];
struct Node {
LL x, y;
};
LL ans;
LL Ksm(LL a, LL b) {
LL ans = 1;
while(b) {
if(b&1) ans = ans*a%mod;
b /= 2;
a = a*a%mod;
}
return ans;
}
Node Solve(int l, int r, int bot) {
int cnt = 0, low = 1e9;
Node ans;
rep(i, l, r)
low = min(low, h[i]);
rep(i, l, r)
if(h[i] == low) cnt++;
if(cnt == r - l + 1) {
if(!low) return (Node) {1, 1};
ans.y = Ksm(2, low - bot);
ans.x = (Ksm(2, r - l + 1) + Ksm(2, low - bot) - 2)%mod;
return ans;
}
LL c1 = 1, c2 = 1;
rep(i, l, r) {
if(h[i] == low) continue;
int cur = i;
while(h[cur + 1] > low && cur < r) cur++;
Node res = Solve(i, cur, low);
i = cur;
c2 = c2*res.y%mod;
c1 = c1*(res.x + res.y)%mod;
}
c1 = (c1*Ksm(2, cnt)%mod + c2*(Ksm(2, low - bot) - 2 + mod)%mod)%mod;
c2 = c2*Ksm(2, low - bot)%mod;
return (Node) {c1, c2};
}
int main() {
cin>>n;
rep(i, 1, n)
cin>>h[i];
ans = 1;
for(int i = 1; i <= n; i++)
if(h[i] > max(h[i - 1], h[i + 1])) {
ans = ans*Ksm(2, h[i] - max(h[i - 1], h[i + 1]))%mod;
h[i] = max(h[i - 1], h[i + 1]);
}
Node tmp = Solve(1, n, 0);
cout<<(ans*tmp.x%mod + mod)%mod<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100, mod = 1e9 + 7;
int n, a[maxn + 3];
int qpow(int a, int b) {
int c = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod) {
if (b & 1) c = 1ll * a * c % mod;
}
return c;
}
pair<int, int> solve(int l, int r, int h) {
if (l == r) {
int x = qpow(2, a[l] - h);
return make_pair(x, x);
}
int mn = a[l];
for (int i = l; i <= r; i++) {
mn = min(mn, a[i]);
}
int c = 1, t = qpow(2, mn - h);
for (int i = l; i <= r; i++) {
if (a[i] == mn) c = 2ll * c % mod;
}
int x = 1, y = 1;
for (int i = l, j = l; i <= r; i = j + 1, j = i) {
if (a[i] == mn) continue;
while (j < r && a[j + 1] != mn) j++;
pair<int, int> t = solve(i, j, mn);
x = 1ll * x * (t.first + t.second) % mod;
y = 1ll * y * t.first % mod;
}
int p = 1ll * t * y % mod;
int q = (1ll * c * x + 1ll * (t + mod - 2) * y) % mod;
return make_pair(p, q);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
printf("%d\n", solve(1, n, 0).second);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int>pii;
const int N=105,mo=1e9+7;
inline int poww(int x,int y){
int ans=1;
for(;y;y>>=1,x=1ll*x*x%mo)if(y&1)ans=1ll*ans*x%mo;
return ans;
}
inline int SS(int x){return poww(2,x+1)-1;}
inline int S(int l,int r){return (SS(r)+mo-SS(l))%mo;}
int n,h[N],hh[N],h2[N],i,j,k,f[N][N],nn,ans;
inline void work(int i,int z,int x){
for(;i<=h2[z];++i)
f[z][i]=(f[z][i]+1ll*x*(hh[i]>1?S(h[z]-hh[i]-1,h[z]-max(1,hh[i-1])-1):0))%mo;
}
int main(){
scanf("%d",&n);
for(i=1;i<=n;++i)scanf("%d",h+i),hh[i]=h[i];
sort(hh+1,hh+n+1);nn=unique(hh+1,hh+n+1)-hh-1;
for(i=1;i<=n;++i)h2[i]=lower_bound(hh+1,hh+nn+1,h[i])-hh;
f[1][0]=2;work(1,1,2);
for(i=1;i<n;++i){
for(j=1;j<=h2[i] && j<=h2[i+1];++j)f[i+1][j]=1ll*(h2[i]<h2[i+1]?poww(2,h[i+1]-h[i]):1)*f[i][j]%mo;
work(h2[i]+1,i+1,(h2[i]==1?2ll:2ll)*f[i][0]%mo);
for(j=0;j<=h2[i];++j)if(!j || j>h2[i+1])f[i+1][0]=(f[i+1][0]+2ll*f[i][j])%mo;
}
for(i=0;i<=h2[n];++i)ans=(ans+f[n][i])%mo;
printf("%d\n",ans);
return 0;
} |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
long long N, H[100009], dp[109][109], mod = 1000000007; vector<pair<int, int>>vec[100009];
long long modpow(long long a, long long b, long long m) {
long long p = 1, q = a;
for (int i = 0; i < 63; i++) {
if ((b / (1LL << i)) % 2 == 1) { p *= q; p %= m; }
q *= q; q %= m;
}
return p;
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) cin >> H[i];
H[0] = 1; H[N + 1] = 1;
for (int i = 1; i <= N; i++) {
long long minx = (1LL << 60);
for (int j = i; j <= N; j++) {
minx = min(minx, H[j]);
if (H[i - 1] < minx && minx > H[j + 1]) vec[j].push_back(make_pair(i, minx - max(H[i - 1], H[j + 1])));
}
}
dp[0][1] = 1;
for (int i = 0; i < N; i++) {
for (int j = 1; j <= N; j++) {
long long K = 0; for (int k = 0; k < vec[i + 1].size(); k++) { if (vec[i + 1][k].first >= j) K += vec[i + 1][k].second; }
long long L = modpow(2, K, mod);
dp[i + 1][j] += dp[i][j] * L; dp[i + 1][j] %= mod;
long long K1 = 0; for (int k = 0; k < vec[i + 1].size(); k++) { if (vec[i + 1][k].first >= i + 1) { K1 += vec[i + 1][k].second; } }
long long L1 = modpow(2, K1, mod);
dp[i + 1][i + 1] += dp[i][j] * L1; dp[i + 1][i + 1] %= mod;
}
}
long long sum = 0;
for (int i = 1; i <= N; i++) sum += dp[N][i];
cout << sum%mod << endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef pair<lint,lint> pll;
typedef long double louble;
#define lf ('\n')
template<typename T1,typename T2> inline T1 max(T1 a,T2 b){return a<b?b:a;}
template<typename T1,typename T2> inline T1 min(T1 a,T2 b){return a<b?a:b;}
namespace ae86
{
const int bufl = 1<<15;
char buf[bufl],*s=buf,*t=buf;
inline int fetch()
{
if(s==t){t=(s=buf)+fread(buf,1,bufl,stdin);if(s==t)return EOF;}
return *s++;
}
inline int ty()
{
int a=0,b=1,c=fetch();
while(!isdigit(c))b^=c=='-',c=fetch();
while(isdigit(c))a=a*10+c-48,c=fetch();
return b?a:-a;
}
}
using ae86::ty;
const int _ = 103 , mo = 1000000007;
inline lint powa(lint a,lint t)
{
lint b=1;
while(t){if(t&1)b=b*a%mo;a=a*a%mo,t>>=1;}
return b;
}
int n,hig[_];
// pll = (not have adjacent same color, have adjacent same color)
pll dfs(int l,int r,int h)
{
int mih=2e9;
for(int i=l;i<=r;i++)mih=min(mih,hig[i]);
pll ans=pll(2,1);
for(int i=l;i<=r;i++)
{
if(hig[i]==mih)ans.second=ans.second*2%mo;
else
{
int j=i;
while(j<r && hig[j+1]>mih)j++;
pll ret=dfs(i,j,mih);
ans.first=ans.first*ret.first%mo;
ans.second=(ret.first+ret.first+ret.second)%mo*ans.second%mo;
i=j;
}
}
ans.second=(ans.second-ans.first+mo)%mo;
ans.first=ans.first*powa(2,mih-h-1)%mo;
return ans;
}
int main()
{
n=ty();
for(int i=1;i<=n;i++)hig[i]=ty();
pll ret=dfs(1,n,0);
printf("%lld\n",(ret.first+ret.second)%mo);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int N = 110;
const int MOD = 1e9+7;
inline int add(int a, int b) { return (a+b)%MOD; }
inline int mul(int a, int b) { return (a*1ll*b)%MOD; }
inline int subt(int a, int b) { a = (a-b)%MOD; return a < 0 ? a+MOD : a; }
int n, H[N];
int pw(int b)
{
int a = 2, ans = 1;
while (b) {
if (b&1) ans = mul(ans, a);
a = mul(a, a);
b >>= 1;
}
return ans;
}
pii solve(int l, int r, int dh)
{
int mn = MOD;
for (int i = l; i <= r; ++i)
mn = min(mn, H[i]);
int all = 1, sw = 2;
for (int i = l; i <= r; ) {
if (H[i] == mn) {
all = mul(all, 2);
++i;
} else {
int j = i;
while (j <= r && H[j] > mn) ++j;
pii ret = solve(i, j-1, mn);
all = mul(all, add( mul(2, ret.second), ret.first ));
sw = mul(sw, ret.second);
i = j;
}
}
int nsw = subt(all, sw);
sw = mul(sw, pw(mn-dh-1));
return pii(nsw, sw);
}
int main()
{
scanf("%d", &n);
for (int i = 0; i < n; ++i)
scanf("%d", &H[i]);
pii ans = solve(0, n-1, 0);
printf("%d\n", add(ans.first, ans.second));
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int dp[103][103] , h[103] , lsh[103] , N , cl;
int poww(long long a , int b){
int times = 1;
while(b){
if(b & 1) times = times * a % MOD;
a = a * a % MOD; b >>= 1;
}
return times;
}
int main(){
lsh[++cl] = 1; cin >> N;
for(int i = 1 ; i <= N ; ++i){cin >> h[i]; lsh[++cl] = h[i];}
sort(lsh + 1 , lsh + cl + 1); cl = unique(lsh + 1 , lsh + cl + 1) - lsh - 1;
for(int i = 1 ; i <= N ; ++i) h[i] = lower_bound(lsh + 1 , lsh + cl + 1 , h[i]) - lsh;
for(int i = 1 ; i <= h[1] ; ++i) dp[1][i] = poww(2 , 1 + lsh[h[1]] - lsh[i]);
for(int i = 1 ; i <= h[1] ; ++i) dp[1][i] = (dp[1][i] - dp[1][i + 1] + MOD) % MOD;
for(int i = 1 ; i < N ; ++i)
if(h[i] >= h[i + 1])
for(int j = 1 ; j <= h[i] ; ++j)
dp[i + 1][min(h[i + 1] , j)] = (dp[i + 1][min(h[i + 1] , j)] + 1ll * dp[i][j] * (1 + (j >= h[i + 1]))) % MOD;
else{
int pw = poww(2 , lsh[h[i + 1]] - lsh[h[i]]);
for(int j = 1 ; j < h[i] ; ++j)
dp[i + 1][j] = 1ll * pw * dp[i][j] % MOD;
for(int j = h[i] ; j <= h[i + 1] ; ++j)
dp[i + 1][j] = 2ll * dp[i][h[i]] * poww(2 , lsh[h[i + 1]] - lsh[j]) % MOD;
for(int j = h[i] ; j <= h[i + 1] ; ++j)
dp[i + 1][j] = (dp[i + 1][j] - dp[i + 1][j + 1] + MOD) % MOD;
}
int sum = 0;
for(int i = 1 ; i <= cl ; ++i) sum = (sum + dp[N][i]) % MOD;
cout << sum; return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int mod=1000000007;
int n,h[110],f[110],mi[110][110];
long long cnt[110][110];
int quickmi(int a,long long b)
{
int t=1;
for (; b; b>>=1,a=1ll*a*a%mod)
if (b&1) t=1ll*t*a%mod;
return t;
}
int main()
{
scanf("%d",&n);
for (int i=1; i<=n; i++) scanf("%d",&h[i]);
for (int i=1; i<=n; i++)
{
mi[i][i]=h[i];
for (int j=i+1; j<=n; j++) mi[i][j]=min(mi[i][j-1],h[j]);
}
for (int i=1; i<=n; i++)
{
cnt[i][i]=h[i];
for (int j=i+1; j<=n; j++) cnt[i][j]=cnt[i][j-1]+max(h[j]-h[j-1],0);
}
for (int i=1; i<n; i++)
{
int H=min(h[i],h[i+1]);
f[i]=quickmi(2,cnt[1][i]-H);
for (int j=1; j<i; j++)
if (h[j]<h[j+1]) f[i]=(f[i]+1ll*f[j]*quickmi(2,cnt[j][i]-h[j]-H+mi[j][i+1]))%mod;
else f[i]=(f[i]+1ll*f[j]*quickmi(2,cnt[j+1][i]-h[j+1]-H+mi[j+1][i+1]))%mod;
}
f[n]=quickmi(2,cnt[1][n]);
for (int j=1; j<n; j++)
if (h[j]<h[j+1]) f[n]=(f[n]+1ll*f[j]*quickmi(2,cnt[j][n]-h[j]+1))%mod;
else f[n]=(f[n]+1ll*f[j]*quickmi(2,cnt[j+1][n]-h[j+1]+1))%mod;
return printf("%d\n",f[n]),0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int N;
int H[105];
ll mo=1000000007;
ll modpow(ll a, ll n = mo-2) {
ll r=1;a%=mo;
while(n) r=r*((n%2)?a:1)%mo,a=a*a%mo,n>>=1;
return r;
}
pair<ll,ll> hoge(int L,int R,int v) {
ll dp1=1,dp2=1;
int i;
if(L>R) return {-1,1};
int mi=1<<30;
for(i=L;i<=R;i++) mi=min(mi,H[i]);
int W=R-L+1;
for(i=L;i<=R;i++) if(mi!=H[i]) W--;
int pre=L-1;
for(i=L;i<=R;i++) {
if(mi==H[i]) {
auto r=hoge(pre+1,i-1,mi);
if(r.first>=0) {
(dp1*=r.first)%=mo;
(dp2*=r.first+r.second)%=mo;
}
pre=i;
}
}
auto r=hoge(pre+1,R,mi);
if(r.first>=0) {
(dp1*=r.first)%=mo;
(dp2*=r.first+r.second)%=mo;
}
(dp2=dp2*modpow(2,W)+(modpow(2,mi-v)+mo-2)*dp1)%=mo;
(dp1*=modpow(2,mi-v))%=mo;
return {dp1,dp2};
}
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N;
for(i=1;i<=N;i++) cin>>H[i];
cout<<hoge(1,N,0).second<<endl;
}
int main()
{
solve();
} |
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
const int inv2 = MOD - MOD/2;
long long modPow(long long a, long long p){
if(p == 0) return 1;
auto res = modPow(a, p/2);
res = (res * res) % MOD;
if(p%2 == 1) res = (res * a) % MOD;
return res;
}
pair<long long, long long> solve(const vector<int>& h, int begin, int end, int curH){
int lowest = 1 << 30, highest = curH;
for(int i=begin;i<end;i++){
lowest = min(lowest, h[i]);
highest = max(highest, h[i]);
}
if(lowest == highest){
return make_pair(modPow(2, lowest - curH), (modPow(2, end - begin) + MOD - 2) % MOD);
}
long long all = 1;
long long one = 1;
int last = -1;
int cnt = 0;
for(int i=begin;i<=end;i++){
if(i == end || h[i] == lowest){
if(i < end) ++cnt;
if(last != -1){
auto p = solve(h, last, i, lowest);
all = (all * (2 * p.first + p.second)) % MOD;
one = (one * p.first) % MOD;
last = -1;
}
} else {
if(last == -1) last = i;
}
}
one = (2 * one) % MOD;
all = (all * modPow(2, cnt)) % MOD;
all = (all + MOD - one) % MOD;
one = (one * modPow(2, lowest - curH - 1)) % MOD;
return make_pair(one, all);
}
int main(){
int N; cin >> N;
vector<int> h(N);
for(auto& t : h) cin >> t;
auto res = solve(h, 0, N, 0);
cout << (res.first + res.second) % MOD << endl;
} |
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int Mod=1e9+7;
int n,h[110];
ll qpow(ll x,ll a){
ll res=1;
while (a){
if (a&1) res=res*x%Mod;
x=x*x%Mod; a>>=1;
}
return res;
}
inline ll calc(int l){
return (qpow(2,l)+Mod-2)%Mod;
}
pii solve(int l,int r,int k){
int mn=h[l],cnt=0;
for (int i=l+1;i<=r;i++) mn=min(mn,h[i]);
for (int i=l;i<=r;i++)
if (h[i]==mn) cnt++;
if (cnt==r-l+1) return pii(calc(r-l+1),qpow(2,mn-k-1));
int tot=r-l+1,s0=1,s1=1,last=0;
for (int i=l;i<=r+1;i++)
if (!last&&h[i]>mn) last=i;
else
if (last&&(h[i]<=mn||i>r)){
tot-=i-last;
pii tmp=solve(last,i-1,mn);
s0=(ll)s0*(tmp.first+4ll*tmp.second%Mod)%Mod;
s1=(ll)s1*(2ll*tmp.second%Mod)%Mod;
last=0;
}
s0=(s0+Mod-s1)%Mod; pii res;
res.first=(ll)s0*qpow(2,tot)%Mod;
res.first=(res.first+(ll)s1*calc(tot)%Mod)%Mod;
res.second=(ll)s1*qpow(2,mn-k-1)%Mod;
return res;
}
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++) scanf("%d",&h[i]);
if (n==1){
printf("%lld\n",qpow(2,h[1]));
return 0;
}
ll mul=1;
for (int i=1;i<=n;i++)
if (h[i]>max(h[i-1],h[i+1])){
mul=mul*qpow(2,h[i]-max(h[i-1],h[i+1]))%Mod;
h[i]=max(h[i-1],h[i+1]);
}
pii ans=solve(1,n,0);
printf("%lld\n",1ll*mul*(ans.first+2ll*ans.second)%Mod);
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
typedef pair<long long, long long> pll;
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int N;
vector<long long> H;
// first: all, second: oxoxoxoxox
pll rec(int left, int right) {
long long resall = 0, resalt = 0;
// height
long long height = 1LL<<60;
for (int i = left; i < right; ++i) if (H[i] < height) height = H[i];
for (int i = left; i < right; ++i) H[i] -= height;
vector<pll> subs;
int nleft = left;
int width = 0;
for (int i = left; i < right; ++i) {
if (H[i] == 0) {
if (i > nleft) subs.push_back(rec(nleft, i));
nleft = i+1;
++width;
}
}
if (right > nleft) subs.push_back(rec(nleft, right));
// second
long long facalt = 1;
for (auto p : subs) facalt *= p.second, facalt %= MOD;
resalt += facalt * modpow(2LL, height, MOD) % MOD;
resalt %= MOD;
// first
resall += resalt;
long long fac = 1;
for (auto p : subs) {
fac *= (p.first + p.second); fac %= MOD;
}
resall += fac * modpow(2LL, width, MOD) % MOD;
resall += MOD - facalt * 2 % MOD;
resall %= MOD;
// result
return pll(resall, resalt);
}
int main() {
cin >> N;
H.resize(N); for (int i = 0; i < N; ++i) cin >> H[i];
pll res = rec(0, N);
cout << res.first << endl;
}
|
/****************************************************************
* Author: huhao
* Email: 826538400@qq.com
* Create time: 2020-03-09 16:15:41
****************************************************************/
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#define fr(i,a,b) for(int i=(a),end_##i=(b);i<=end_##i;i++)
#define fd(i,a,b) for(int i=(a),end_##i=(b);i>=end_##i;i--)
int read()
{
int r=0,t=1,c=getchar();
while(c<'0'||c>'9')
{
t=c=='-'?-1:1;
c=getchar();
}
while(c>='0'&&c<='9')
{
r=(r<<3)+(r<<1)+(c^48);
c=getchar();
}
return r*t;
}
#define i64 long long
const int N=100010,L=20,mod=1000000007,i2=(mod+1)/2;
i64 power(i64 a,i64 b,i64 p)
{
i64 r=1;
for(;b;b>>=1,a=a*a%p) if(b&1) r=r*a%p;
return r;
}
int n,h[N],m[N][L+2],b[N];
int Min(int a,int b){ return h[a]<h[b]?a:b; }
int cmin(int l,int r)
{
int B=b[r-l+1];
return Min(m[l][B],m[r-(1<<B)+1][B]);
}
#define info std::pair<i64,i64>
info operator+(info a,i64 b){ a.first-=a.second; a.second=a.second*power(2,b,mod)%mod; return info((a.first+a.second+mod)%mod,a.second); }
info operator+(info a,info b){ return info(a.first*b.first%mod,a.second*b.second%mod*i2%mod); }
info calc(int l,int r,int H)
{
if(l>r) return info(1,2);
if(l==r) return info(2,2)+(h[l]-H-1);
int m=cmin(l,r);
return (calc(l,m-1,h[m]-1)+info(2,2)+calc(m+1,r,h[m]-1))+(h[m]-H-1);
}
int main()
{
n=read();
fr(i,1,n) h[i]=read();
fr(i,2,n) b[i]=b[i>>1]+1;
fr(i,1,n) m[i][0]=i;
fr(j,1,L) fr(i,1,n-(1<<j)+1) m[i][j]=Min(m[i][j-1],m[i+(1<<(j-1))][j-1]);
printf("%d\n",int(calc(1,n,0).first));
return 0;
} |
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
typedef pair<int, int> pii;
#define fi first
#define se second
#define mp make_pair
const int MAXN = 100;
const int MOD = int(1E9) + 7;
inline int add(int x, int y) {x += y; return x >= MOD ? x - MOD : x;}
inline int sub(int x, int y) {x -= y; return x < 0 ? x + MOD : x;}
inline int mul(int x, int y) {return 1LL * x * y % MOD;}
int pow_mod(int b, int p) {
int ret = 1;
for(int i=p;i;i>>=1,b=mul(b,b))
if( i & 1 ) ret = mul(ret, b);
return ret;
}
int h[MAXN + 5], N;
pii get(int l, int r, int lh) {
int mn = h[l];
for(int i=l;i<=r;i++)
mn = min(mn, h[i]);
int lst = l; pii ret = mp(1, 1);
for(int i=l;i<=r;i++) {
if( h[i] == mn ) {
if( i > lst ) {
pii tmp = get(lst, i - 1, mn);
ret.fi = mul(ret.fi, tmp.fi);
ret.se = mul(ret.se, add(mul(2, tmp.fi), tmp.se));
}
ret.se = mul(ret.se, 2);
lst = i + 1;
}
}
if( r >= lst ) {
pii tmp = get(lst, r, mn);
ret.fi = mul(ret.fi, tmp.fi);
ret.se = mul(ret.se, add(mul(2, tmp.fi), tmp.se));
}
return mp(mul(ret.fi, pow_mod(2, mn - lh)), sub(ret.se, mul(2, ret.fi)));
}
int main() {
scanf("%d", &N);
for(int i=1;i<=N;i++) scanf("%d", &h[i]);
pii k = get(1, N, 0);
printf("%d\n", add(k.fi, k.se));
} |
#include<bits/stdc++.h>
using namespace std;
long long h[200009];
long long dp[109];
long long mod = 1e9+7;
vector< pair<long long,long long> > v[109];
long long exp(long long b){
if(!b) return 1;
if(b&1) return 2*exp(b-1)%mod;
long long k = exp(b/2);
return k*k%mod;
}
int main(){
long long n;
cin >> n;
for(long long i = 1; i <= n; i++){
cin >> h[i];
}
for(long long i = 1; i <= n; i++){
if(h[i-1] > h[i]) continue;
long long lo = max((long long)2,h[i-1]+1), hi = h[i];
for(long long j = i; j <= n; j++){
if(max((long long)0,hi - max(lo,h[j]+1)+1)) v[i].push_back({j-1,max((long long)0,hi - max(lo,h[j]+1)+1)});
hi = min(hi,h[j]);
}
if(max((long long)0,hi-lo+1)) v[i].push_back({n,max((long long)0,hi-lo+1)});
}
for(long long i = n; i >= 1; i--){
for(long long j = i; j <= n; j++){
long long A = 0;
for(long long k = i; k <= j; k++){
for(long long t= 0; t < v[k]. size(); t++){
long long r = v[k][t].first, N = v[k][t].second;
if(r <= j) A+= N;
}
}
if(j == n) dp[i] = (dp[i] + exp(A)) % mod;
else dp[i] = (dp[i] + dp[j+1] * exp(A))% mod;
}
}
cout<< dp[1] * 2 % mod << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const ll MAX=105;
const ll INF=0x3f3f3f3f;
const ll MOD=1e9+7;
ll N,ans,h[MAX],dp[MAX][MAX],order[MAX],hg[MAX],hg_cnt;
pll g[MAX];
ll power(ll x,ll y){
if(y==0) return 1;
ll t=power(x,y/2);
if(y%2) return t*t%MOD*x%MOD;
return t*t%MOD;
}
int main(){
scanf("%lld",&N);
for(ll i=0;i<N;i++) {
scanf("%lld",&h[i]);
g[i].first=h[i],g[i].second=i;
}
sort(g,g+N);
hg[hg_cnt++]=1;
for(ll i=0;i<N;i++) {
if(hg[hg_cnt-1]!=g[i].first) hg[hg_cnt++]=g[i].first;
order[g[i].second]=hg_cnt-1;
}
dp[0][order[0]]=2;
for(ll i=0;i<order[0];i++) dp[0][i]=(power(2,hg[order[0]]-hg[i]+1)-power(2,hg[order[0]]-hg[i+1]+1)+MOD)%MOD;
for(ll i=1;i<N;i++){
for(ll j=0;j<=min(order[i],order[i-1])-1;j++) dp[i][j]=dp[i-1][j];
for(ll j=min(order[i],order[i-1]);j<=order[i-1];j++) dp[i][min(order[i],order[i-1])]+=2*dp[i-1][j],dp[i][min(order[i],order[i-1])]%=MOD;
if(order[i]>order[i-1]){
ll t=power(2,hg[order[i]]-hg[order[i-1]]);
for(ll j=0;j<order[i-1];j++) dp[i][j]=(dp[i][j]*t)%MOD;
dp[i][order[i]]=dp[i][order[i-1]];
for(ll j=order[i]-1;j>=order[i-1];j--) dp[i][j]=(power(2,hg[order[i]]-hg[j])-power(2,hg[order[i]]-hg[j+1])+MOD)*dp[i][order[i-1]]%MOD;
}
}
for(ll i=0;i<=order[N-1];i++) ans+=dp[N-1][i],ans%=MOD;
printf("%lld\n",ans);
return 0;
}
|
#include <algorithm>
#include <iostream>
#define mod 1000000007
#define maxn 1003
using namespace std;
int h[maxn], a[maxn], b[maxn], _h[maxn], _a[maxn], f[maxn][maxn];
int fpw(int x, int y){
if (y < 0)
return 1;
int ans = 1;
for (int i = 1; i <= y; i <<= 1, x = 1LL * x * x % mod)
if (y & i)
ans = 1LL * ans * x % mod;
return ans;
}
int main(){
int n;
cin >> n;
for (int i = 1; i <= n; ++ i){
cin >> h[i];
a[i] = h[i];
}
sort(a + 1, a + 1 + n);
int _n = 0;
for (int i = 1; i <= n; ++ i)
if (a[i] != a[i - 1])
_a[++ _n] = a[i];
for (int i = 1; i <= n; ++ i)
_h[i] = lower_bound(_a + 1, _a + 1 + _n, h[i]) - _a;
f[0][0] = 1;
for (int i = 1; i <= n; ++ i){
f[i][0] = f[i - 1][0] * 2 % mod;
for (int j = _h[i] + 1; j <= _h[i - 1]; ++ j)
f[i][0] = (f[i][0] + f[i - 1][j] * 2 % mod) % mod;
int x = fpw(2, h[i] - h[i - 1]);
for (int j = 1; j <= min(_h[i], _h[i - 1]); ++ j)
f[i][j] = 1LL * f[i - 1][j] * x % mod;
for (int j = _h[i - 1] + 1; j <= _h[i]; ++ j){
if (j > 1)
f[i][j] = 1LL * f[i - 1][0] * (fpw(2, _a[j] - _a[j - 1]) - 1) % mod * 2 % mod * fpw(2, h[i] - _a[j]) % mod;
else
f[1][1] = 1LL * f[0][0] * (fpw(2, _a[1]) - 2) % mod * fpw(2, h[i] - _a[1]) % mod;
}
}
int ans = 0;
for (int i = 0; i <= _h[n]; ++ i)
ans = (ans + f[n][i]) % mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1e9+1;
const int MOD = 1e9+7;
int mod_pow(int x, int n){
int res = 1;
while ( n ) {
if ( n & 1 ) (res *= x) %= MOD;
(x *= x) %= MOD;
n >>= 1;
}
return res;
}
int N;
vector<int> h;
vector<vector<int> > dp1, dp2;
void dfs(int l, int r) {
int mi = INF;
for ( int i = l; i < r; i++ ) mi = min(mi, h[i]);
for ( int i = l; i < r; i++ ) h[i] -= mi;
int cnt_mi = 0;
vector<int> p{l-1};
for ( int i = l; i < r; i++ ) {
if ( h[i] == 0 ) {
cnt_mi++;
p.emplace_back(i);
}
}
p.emplace_back(r);
//cnt_mi = max(1LL, cnt_mi);
int mpow1 = mod_pow(2, cnt_mi);
int mpow2 = mod_pow(2, mi);
dp1[l][r] = dp2[l][r] = 1;
for ( int i = 0; i < (int)p.size()-1; i++ ) {
if ( p[i]+1 >= p[i+1] ) continue;
dfs(p[i]+1, p[i+1]);
(dp1[l][r] *= (dp1[p[i]+1][p[i+1]]+dp2[p[i]+1][p[i+1]])) %= MOD;
(dp2[l][r] *= dp2[p[i]+1][p[i+1]]) %= MOD;
}
(dp1[l][r] = mpow1*dp1[l][r]%MOD + (mpow2+MOD-2)*dp2[l][r]%MOD) %= MOD;
(dp2[l][r] *= mpow2) %= MOD;
for ( int i = l; i < r; i++ ) h[i] += mi;
}
signed main() {
cin >> N;
h = vector<int>(N);
for ( int i = 0; i < N; i++ ) cin >> h[i];
dp1 = dp2 = vector<vector<int> >(N+1, vector<int>(N+1, 0));
dfs(0, N);
cout << dp1[0][N] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-9;
const ll mod=1e9+7;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll Pow(ll n,ll p){
ll r=1;
for(;p>0;p>>=1){
if(p&1) r=(r*n)%mod;
n=(n*n)%mod;
}
return r;
}
ll n;
vl a;
vvl dp,DP;
int main(){
cin>>n;
a=vl(n+2);
dp=DP=vvl(n+2,vl(n+2));
for(int i=1;i<=n;i++) cin>>a[i];
for(int k=0;k<n;k++) for(int i=1;i<=n;i++) if(i+k<=n&&a[i-1]<a[i]||a[i+k]>a[i+k+1]){
ll L=i,R=i+k,m=inf,M=max(a[i-1],a[i+k+1]);
for(int j=L;j<=R;j++) m=min(m,a[j]);
if(m<=M) continue;
vi b,c;
ll I=L,t=0;
for(int j=L;j<=R;j++) if(a[j]==m){
t++;
if(I!=j){
b.push_back(I);
c.push_back(j-1);
}
I=j+1;
}
if(I!=R+1){
b.push_back(I);
c.push_back(R);
}
if(t==R-L+1){
dp[L][R]=Pow(2,m-M-1);
DP[L][R]=(Pow(2,t)+mod-2)%mod;
continue;
}
ll S=b.size(),res=1,sum=Pow(2,t);
for(int j=0;j<S;j++){
int l=b[j],r=c[j];
(res*=2*dp[l][r])%=mod;
(sum*=4*dp[l][r]+DP[l][r])%=mod;
}
(sum+=2*mod-2*res)%=mod;
(res*=Pow(2,m-M-1))%=mod;
dp[L][R]=res,DP[L][R]=sum;
}
cout<<(2*dp[1][n]+DP[1][n])%mod<<endl;
} |
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
struct state {
int h;
long long ans1 = 2;
long long ans2 = 0;
state(int h) : h(h) {}
};
int n, m = 1000000007;
int h[100];
long long powmod(long long x, long long y) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = ans * x % m;
x = x * x % m;
y >>= 1;
}
return ans;
}
long long mod_inverse(long long a, long long m) {
long long b = m, x = 1, y = 0;
while (b) {
long long t = a / b;
a -= t * b;
x -= t * y;
swap(a, b);
swap(x, y);
}
return (m + x % m) % m;
}
long long solve() {
int i, j;
vector <state> v;
v.push_back(state(0));
for (i = 0; i < n; i++) {
v.push_back(state(h[i]));
}
v.push_back(state(0));
while (v.size() > 3) {
int x = 0;
for (i = 0; i < v.size(); i++) {
if (v[i].h > v[x].h) x = i;
}
if (v[x].h == v[x + 1].h) {
long long tmp1, tmp2;
tmp1 = v[x].ans1 * v[x + 1].ans1 % m * mod_inverse(2, m) % m;
tmp2 = ((v[x].ans1 + v[x].ans2) * (v[x + 1].ans1 + v[x + 1].ans2) - tmp1 + m) % m;
v[x].ans1 = tmp1;
v[x].ans2 = tmp2;
v.erase(v.begin() + x + 1);
} else {
int h = v[x].h - max(v[x - 1].h, v[x + 1].h);
v[x].ans1 = v[x].ans1 * powmod(2, h) % m;
v[x].h -= h;
}
}
return (v[1].ans1 * powmod(2, v[1].h - 1) % m + v[1].ans2) % m;
}
int main() {
int i;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &h[i]);
printf("%lld\n", solve());
return 0;
}
|
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
const int MAX = 210000;
const int MOD = 1000000007;
typedef pair<long long, long long> pll;
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int N;
vector<long long> H;
// first: all, second: oxoxoxoxox
pll rec(int left, int right) {
long long resall = 0, resalt = 0;
// height
long long height = 1LL<<60;
for (int i = left; i < right; ++i) if (H[i] < height) height = H[i];
for (int i = left; i < right; ++i) H[i] -= height;
vector<pll> subs;
int nleft = left;
int width = 0;
for (int i = left; i < right; ++i) {
if (H[i] == 0) {
if (i > nleft) subs.push_back(rec(nleft, i));
nleft = i+1;
++width;
}
}
if (right > nleft) subs.push_back(rec(nleft, right));
// second -> second
long long facalt = 1;
for (auto p : subs) facalt *= p.second, facalt %= MOD;
resalt += facalt * modpow(2LL, height, MOD) % MOD;
resall += resalt;
// first (not second)
long long fac = 1;
for (auto p : subs) {
fac *= (p.first + p.second); fac %= MOD;
}
resall += fac * modpow(2LL, width, MOD) % MOD;
resall += MOD - facalt * 2 % MOD;
// result
return pll(resall % MOD, resalt % MOD);;
}
int main() {
cin >> N;
H.resize(N); for (int i = 0; i < N; ++i) cin >> H[i];
pll res = rec(0, N);
cout << res.first << endl;
}
|
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
const int mod = 1e9+7;
int ad(int x,int y) { x+=y; return x>=mod?x-mod:x; }
int mu(int x,int y) { return 1ll*x*y%mod; }
int sb(int x,int y) { x-=y; return x<0?x+mod:x; }
int ksm(int a,int b) {
int ans = 1;
for(;b;b>>=1,a=mu(a,a))
if(b&1) ans = mu(ans,a);
return ans;
}
int n,h[1005];
struct node{
int s0,s1;
}; //s0 no xiangling s1 suiyi
node DC(int l,int r,int lm) {
int x0 = 1 , x1 = 1 , cc = 0;
int mimi = 0x3f3f3f3f;
for(int i=l;i<=r;i++) {
mimi = min(mimi,h[i]);
}
for(int i=l;i<=r;i++) cc += (h[i]==mimi);
for(int i=l,j;i<=r;i=j+1) {
j = i;
if(h[i]>mimi) {
while(j+1<=r&&h[j+1]!=mimi) j++;
node yoo = DC(i,j,mimi);
x0 = mu(x0,yoo.s0); x1 = mu(x1,ad(yoo.s0,yoo.s1));
}
}
return (node){mu(x0,ksm(2,mimi-lm)),ad(mu(x0,sb(ksm(2,mimi-lm),2) ),mu(x1,ksm(2,cc))) };
}
int main() {
scanf("%d",&n);
for(int i=1;i<=n;i++) {
scanf("%d",&h[i]);
}
node ans = DC(1,n,0);
printf("%d",ans.s1);
}
// |
#include<iostream>
#define f first
#define s second
#define mod 1000000007
using namespace std;
int n, i;
int v[105];
pair<int, int> sol;
int mult(int x, int e){
if(e == 0){
return 1;
}
else{
int a = mult(x, e / 2);
if(e % 2 == 0){
return a * 1LL * a % mod;
}
else{
return a * 1LL * a % mod * x % mod;
}
}
}
pair<int, int> solve(int st, int dr){
pair<int, int> sol;
if(st == dr){
sol.s = 0;
sol.f = mult(2, v[st]);
return sol;
}
int minim = 1000000000, nr = 0, num = 0, p, aux = 2, i;
for(i = st; i <= dr; i++){
minim = min(minim, v[i]);
}
for(i = st; i <= dr; i++){
v[i] -= minim;
}
pair<int, int> d[105];
p = st - 1;
for(i = st; i <= dr; i++){
if(v[i] == 0){
num++;
if(p != i - 1){
d[++nr] = solve(p + 1, i - 1);
}
p = i;
}
}
if(p != dr){
d[++nr] = solve(p + 1, dr);
}
sol.f = mult(2, minim);
sol.s = mult(2, num);
for(i = 1; i <= nr; i++){
sol.f = sol.f * 1LL * d[i].f % mod;
sol.s = (2LL * d[i].f + d[i].s) * sol.s % mod;
aux = aux * 1LL * d[i].f % mod;
}
sol.s -= aux;
if(sol.s < 0){
sol.s += mod;
}
return sol;
}
int main(){
cin>> n;
for(i = 1; i <= n; i++){
cin>> v[i];
}
sol = solve(1, n);
sol.f = (sol.f + sol.s) % mod;
cout<< sol.f;
return 0;
}
|
#include <iostream>
#include <vector>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <queue>
using namespace std;
typedef long long ll;
const ll INF = 1e9, MOD = 1e9 + 7, MOD2 = 1e6 + 3;
string s;
ll dp[100][2], last[100];
ll p[100], sz[100], n;
vector < pair <ll, ll> > v;
ll qpow (ll a, ll b) {
ll s = 1;
while (b) {
if (b & 1) s = s * a % MOD;
a = a * a % MOD;
b /= 2;
}
return s;
}
ll find (ll x) {
if (x == p[x]) return x;
return p[x] = find (p[x]);
}
void actualize (ll x, ll y) {
dp[x][0] = dp[x][0] * qpow (2, last[x] - y) % MOD;
last[x] = y;
}
void unite (ll a, ll b) {
a = find (a);
b = find (b);
if (a == b) return;
if (sz[a] < sz[b]) swap (a, b);
actualize (a, min (last[a], last[b]));
actualize (b, min (last[a], last[b]));
dp[a][1] = (dp[a][1] * (2 * dp[b][0] % MOD + dp[b][1]) % MOD) % MOD + 2 * dp[a][0] * (dp[b][0] + dp[b][1]) % MOD;
dp[a][0] = dp[a][0] * dp[b][0] % MOD;
p[b] = a;
sz[a] += sz[b];
}
int main () {
cin >> n;
for (ll i = 0; i < n; i++) {
ll h;
scanf ("%lld", &h);
last[i] = h;
v.emplace_back (h, i);
dp[i][0] = 1;
dp[i][1] = 0;
sz[i] = 1;
p[i] = i;
}
sort (v.begin(), v.end());
reverse (v.begin(), v.end());
for (auto a : v) {
if (a.second != n - 1 && last[a.second + 1] >= last[a.second]) {
unite (a.second, a.second + 1);
}
if (a.second && last[a.second - 1] >= last[a.second]) {
unite (a.second - 1, a.second);
}
}
actualize (find (0), 1);
cout << (2 * dp[find (0)][0] + dp[find (0)][1]) % MOD;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
typedef pair <LL, LL> pii;
const LL MOD = 1000000007LL;
const int MAXN = 105, INF = 1000000001;
int n, h[MAXN];
inline LL mul(LL a, LL b){return a * b % MOD;}
inline LL quickPow(LL base, int times){
LL ret = 1LL;
while(times){
if(times & 1) ret = ret * base % MOD;
base = base * base % MOD;
times >>= 1;
} return ret;
}
pii solve(int l, int r, int b){
int i, j, mn = INF; pii f, tmp;
for(i = l; i <= r; ++ i)
if(h[i] < mn) mn = h[i];
for(i = l; i <= r; i = j + 1)
if(h[i] > mn){
for(j = i; j < r && h[j + 1] > mn; ++ j) ;
tmp = solve(i, j, mn);
if(i == l) f = pii(mul(tmp.first, 2), tmp.second);
else f = pii(mul(mul(tmp.first, f.first), 2), (mul(mul(f.first, tmp.first), 4) + mul(mul(f.first, tmp.second), 2) + mul(mul(f.second, tmp.first), 4) + mul(f.second, tmp.second)) % MOD);
}else{
j = i;
if(i == l) f = pii(1, 0);
else f = pii(f.first, (f.first * 2 + f.second * 2) % MOD);
}
return pii(f.first * quickPow(2, mn - b - 1) % MOD, f.second);
}
int main(){
scanf("%d", &n);
for(int i = 1; i <= n; ++ i)
scanf("%d", &h[i]);
auto ret = solve(1, n, 0);
printf("%d\n", int((ret.first * 2 + ret.second) % MOD));
return 0;
} |
#include <cstdio>
#include <cstring>
#include <algorithm>
#define P 1000000007
using namespace std;
typedef long long ll;
ll h[111], Mn[111][111], Sm[111][111], SS[111][111], n;
ll F[111];
ll powmod(ll x, ll y = P - 2, ll p = P) {
ll ans = 1;
while(y) {
if(y & 1) ans = ans * x % p;
x = x * x % p;
y >>= 1;
}
return ans;
}
ll calc(ll a, ll q, ll n) {
return (powmod(2, a + q * n) - powmod(2, a)) * powmod(powmod(2, q) - 1) % P;
}
int main() {
scanf("%lld", &n);
for(int i = 1; i <= n; i++) scanf("%lld", &h[i]);
h[0] = (h[n + 1] = 1);
for(int i = 1; i <= n; i++) {
Mn[i][i] = h[i], Sm[i][i] = h[i], SS[i][i] = h[i];
for(int j = i + 1; j <= n; j++) Mn[i][j] = min(Mn[i][j - 1], h[j]), Sm[i][j] = Sm[i][j - 1] + h[j], SS[i][j] = SS[i][j - 1] + max(h[j] - h[j - 1], 0ll);
}
F[0] = 1;
for(int i = 1; i <= n; i++) {
F[i] = F[i - 1] * 2 % P;
for(int j = 1; j <= i; j++) {
int r = Mn[j][i], l = max(h[i + 1], h[j - 1]) + 1;
if(l <= r) F[i] = (F[i] + 2 * F[j - 1] * calc(SS[j][i] - r, 1, r - l + 1)) % P;
}
}
printf("%lld\n", (F[n] % P + P) % P);
return 0;
}
|
#include <bits/stdc++.h>
typedef long long LL;
using namespace std;
const int N=105;
const int MOD=1000000007;
int n,f[N][N],a[N],w[N],m;
int ksm(int x,int y){
if (y<0) return 1;
int ans=1;
while (y){
if (y&1) ans=(LL)ans*x%MOD;
x=(LL)x*x%MOD;y>>=1;
}
return ans;
}
int solution(){
for(int i=1;i<=n;i++){
w[++m] = a[i];
}
sort(w+1,w+m+1);
m = unique(w+1,w+m+1)-w-1;
for (int i=1;i<=n;i++) a[i]=lower_bound(w+1,w+m+1,a[i])-w;
f[0][0]=1;
for (int i=1;i<=n;i++)
{
for (int j=a[i]+1;j<=a[i-1];j++) (f[i][0]+=f[i-1][j]*2%MOD)%=MOD;
(f[i][0]+=f[i-1][0]*2%MOD)%=MOD;
for (int j=1;j<=a[i];j++)
{
f[i][j]=(LL)f[i-1][j]*ksm(2,w[a[i]]-w[a[i-1]])%MOD;
if (a[i-1]>=j) continue;
if (j>1) (f[i][j]+=(LL)f[i-1][0]*(ksm(2,w[j]-w[j-1])-1)%MOD*2%MOD*ksm(2,w[a[i]]-w[j])%MOD)%=MOD;
else (f[i][j]+=(LL)f[i-1][0]*(ksm(2,w[j])-2)%MOD*ksm(2,w[a[i]]-w[j])%MOD)%=MOD;
}
}
int ans=0;
for (int i=0;i<=m;i++) (ans+=f[n][i])%=MOD;
return ans;
}
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++) scanf("%d",&a[i]);
int res = solution();
cout<<res<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
long long modPow(long long a, long long p){
if(p == 0) return 1;
long long res = modPow(a, p/2);
res = (res * res) % MOD;
if(p%2 == 1) res = (res * a) % MOD;
return res;
}
pair<long long, long long> solve(const vector<int>& h){
if(h.empty()) return make_pair(1, 1);
int minH = h[0];
for(auto& t : h) minH = min(t, minH);
if(minH > 1){
vector<int> nh = h;
for(auto& t : nh) t -= minH - 1;
auto res = solve(nh);
long long p2 = modPow(2, minH - 1);
res.first = (res.first + (2 * p2 + MOD - 2) % MOD * res.second) % MOD;
res.second = (res.second * p2) % MOD;
return res;
} else {
for(int i=0;i<h.size();i++){
if(h[i] == 1){
vector<int> h1, h2;
for(int j=0;j<i;j++) h1.push_back(h[j]);
for(int j=i+1;j<h.size();j++) h2.push_back(h[j]);
auto res1 = solve(h1);
auto res2 = solve(h2);
pair<long long, long long> res;
res.first = 2 * res1.first * res2.first % MOD;
res.second = res1.second * res2.second % MOD;
return res;
}
}
}
return make_pair(0, 0);
}
int main(){
int N;
while(cin >> N){
vector<int> h(N);
for(auto& t : h) cin >> t;
cout << solve(h).first << endl;
}
} |
#include<bits/stdc++.h>
#define For(i,j,k) for (int i=(int)(j);i<=(int)(k);i++)
#define Rep(i,j,k) for (int i=(int)(j);i>=(int)(k);i--)
#define UPD(x,y) (((x)+=(y))>=mo?(x)-=mo:233)
#define CLR(a,v) memset(a,v,sizeof(a))
using namespace std;
const int mo=1000000007;
int power(int x,int y){
int s=1;
for (;y;y/=2,x=1ll*x*x%mo)
if (y&1) s=1ll*s*x%mo;
return s;
}
const int N=105;
int a[N],mn[N][N];
int fxor[N][N];
int pre[N][N];
int suf[N][N];
int mx[N],g[N],n;
int main(){
scanf("%d",&n); n++;
For(i,2,n) scanf("%d",&a[i]);
a[0]=a[1]=a[n+1]=a[n+2]=1;
For(i,0,n+2) mn[i][i]=i;
For(l,0,n+2) For(r,l+1,n+2)
mn[l][r]=(a[r]<a[mn[l][r-1]]?r:mn[l][r-1]);
For(i,1,n+2) fxor[i][i-1]=1;
Rep(l,n+1,1) For(r,l,n+1){
int dn=max(a[l-1],a[r+1]),md=mn[l][r];
if (a[md]>=dn) fxor[l][r]=1ll*power(2,a[md]-dn)*fxor[l][md-1]%mo*fxor[md+1][r]%mo;
}
For(l,0,n+2){
CLR(mx,0); mx[l]=a[l];
For(i,l+1,n+2) mx[i]=min(a[i],mx[i-1]);
int tmp=pre[l][l]=1,las=l;
For(r,l+1,n+2){
pre[l][r]=1ll*tmp*fxor[las+1][r-1]%mo;
if (mx[r]>=a[r]) tmp=1ll*tmp*fxor[las+1][r-1]%mo,las=r;
}
}
For(r,0,n+2){
CLR(mx,0); mx[r]=a[r];
Rep(i,r-1,0) mx[i]=min(a[i],mx[i+1]);
int tmp=suf[r][r]=1,las=r;
Rep(l,r-1,0){
suf[l][r]=1ll*tmp*fxor[l+1][las-1]%mo;
if (mx[l]>=a[l]) tmp=1ll*tmp*fxor[l+1][las-1]%mo,las=l;
}
}
g[1]=1;
For(i,2,n+2) For(j,1,i-1){
int md=mn[j-1][i];
UPD(g[i],1ll*g[j]*pre[j-1][md]%mo*suf[md][i]%mo);
}
printf("%d\n",1ll*g[n+2]*500000004ll%mo);
} |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
using uint64 = unsigned long long;
const int64 MOD = 1e9 + 7;
constexpr int MAX_N = 100;
int64 h[MAX_N];
int64 powMod(int64 a, int64 n)
{
int64 res = 1;
a = a % MOD;
while (n > 0)
{
if (n % 2 == 1)
{
res = (res * a) % MOD;
}
a = (a * a) % MOD;
n >>= 1;
}
return res;
}
int times = 0;
pair<int64, int64> counting(int l, int r, int offset)
{
if (l == r)
{
return {1, 0};
}
int64 cnt1 = 1, cnt2 = 1,
minHeight = *min_element(h + l, h + r);
int rectL = l, x = 0;
for (int i = l; i < r; i++)
{
if (h[i] == minHeight)
{
auto cres = counting(rectL, i, minHeight);
cnt1 = (cnt1 * cres.first) % MOD;
cnt2 = (cnt2 * (cres.first + cres.second)) % MOD;
rectL = i + 1;
x++; // 上に乗っかっていない
}
}
auto cres = counting(rectL, r, minHeight);
cnt1 = (cnt1 * cres.first) % MOD;
cnt2 = (cnt2 * (cres.first + cres.second)) % MOD;
int height = minHeight - offset;
cnt2 = (powMod(2, x) * cnt2 % MOD + cnt1 * ((powMod(2, height) + MOD - 2) % MOD)) % MOD;
cnt1 = powMod(2, height) * cnt1 % MOD;
return {cnt1, cnt2};
}
int main()
{
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N;
cin >> N;
for (int i = 0; i < N; i++)
{
cin >> h[i];
}
cout << counting(0, N, 0).second << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define N 105
#define mod 1000000007
using namespace std;
ll n,f[N][N],h[N],w[N],tot;
inline ll ksm(ll x,ll p){
if(p<0)return 1;
ll ret=1;
while(p){
if(p&1)ret=ret*x%mod;
x=x*x%mod;
p>>=1;
}
return ret;
}
int main(){
scanf("%lld",&n);
for(ll i=1;i<=n;++i)scanf("%lld",&h[i]),w[++tot]=h[i];
sort(w+1,w+tot+1);
tot=unique(w+1,w+tot+1)-w-1;
for(ll i=1;i<=n;++i)h[i]=lower_bound(w+1,w+tot+1,h[i])-w;
f[0][0]=1;
for(ll i=1;i<=n;++i){
for(ll j=h[i]+1;j<=h[i-1];++j)(f[i][0]+=f[i-1][j]*2%mod)%=mod;
(f[i][0]+=f[i-1][0]*2%mod)%=mod;
for(ll j=1;j<=h[i];++j){
f[i][j]=(ll)f[i-1][j]*ksm(2,w[h[i]]-w[h[i-1]])%mod;
if(h[i-1]>=j)continue;
if(j>1)(f[i][j]+=(ll)f[i-1][0]*(ksm(2,w[j]-w[j-1])-1)%mod*2%mod*ksm(2,w[h[i]]-w[j])%mod)%=mod;
else (f[i][j]+=(ll)f[i-1][0]*(ksm(2,w[j])-2)%mod*ksm(2,w[h[i]]-w[j])%mod)%=mod;
}
}
ll ans=0;
for(ll i=0;i<=tot;++i)(ans+=f[n][i])%=mod;
printf("%lld",ans);
return 0;
} |
/*Lower_Rating*/
/*Ex*/
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<stack>
#include<vector>
#include<queue>
#include<bitset>
#include<set>
using namespace std;
#define LL long long
#define DB double
#define MOD 1000000007
#define Pr pair<int,int>
#define X first
#define Y second
#define MAXN 200
#define eps 1e-10
#define INF 1000000000
#define mem(x,p) memset(x,p,sizeof(x))
LL read(){
LL x=0,F=1;char c=getchar();
while(c<'0'||c>'9'){if(c=='-')F=-1;c=getchar();}
while(c>='0'&&c<='9'){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
return x*F;
}
int add(int a,int b){return (a+b>=MOD)?a+b-MOD:a+b;}
int dec(int a,int b){return (a-b<0)?a-b+MOD:a-b;}
int mul(LL a,int b){return a*b%MOD;}
int fst_pow(int a,int b){
int res=1;
while(b){
if(b&1)res=mul(res,a);
a=mul(a,a);
b>>=1;
}return res;
}
int n,a[MAXN+5];
Pr solve(int l,int r,int c){
if(l>r)return Pr(1,0);
int mh=INF;
for(int i=l;i<=r;i++)mh=min(mh,a[i]);
vector<int> pos;
pos.push_back(l-1);
for(int i=l;i<=r;i++)
if(a[i]==mh)pos.push_back(i);
pos.push_back(r+1);
int w=pos.size()-2;
Pr tmp,v;tmp=Pr(1,1);
for(int i=0;i<pos.size()-1;i++){
v=solve(pos[i]+1,pos[i+1]-1,mh);
tmp.X=mul(tmp.X,v.X);
tmp.Y=mul(tmp.Y,add(v.X,v.Y));
}
return Pr(mul(tmp.X,fst_pow(2,mh-c)),add(mul(tmp.X,dec(fst_pow(2,mh-c),2)),mul(tmp.Y,fst_pow(2,w))));
}
int main(){
n=read();
for(int i=1;i<=n;i++)a[i]=read();
printf("%d",solve(1,n,0).Y);
}
|
#include <iostream>
#define llint long long
#define mod 1000000007
using namespace std;
llint n;
llint a[105], b[105];
llint num[105][105];
llint dp[105];
llint modpow(llint a, llint n)
{
if(n == 0) return 1;
if(n % 2){
return ((a%mod) * (modpow(a, n-1)%mod)) % mod;
}
else{
return modpow((a*a)%mod, n/2) % mod;
}
}
int main(void)
{
cin >> n;
for(int i = 1; i <= n; i++) cin >> a[i], a[i]--;
llint mul = 1;
for(int i = 1; i <= n; i++){
mul *= modpow(2, max(0LL, a[i] - max(a[i-1], a[i+1]))), mul %= mod;
a[i] = min(a[i], max(a[i-1], a[i+1]));
}
for(int i = 1; i <= n-1; i++) b[i] = min(a[i], a[i+1]);
for(int l = 1; l <= n-1; l++){
for(int r = 1; r <= n-1; r++){
if(l > r) continue;
llint sum = 0;
for(int i = l-1; i <= r; i++){
if(b[i+1] >= b[i]) sum += b[i+1]-b[i];
else{
llint d = b[i]-b[i+1], x = min(sum, d);
num[l][r] += x, num[l][r] %= mod-1, sum -= x;
}
}
}
}
dp[0] = 1;
for(int i = 1; i <= n; i++){
for(int j = 0; j < i; j++){
dp[i] += dp[j] * modpow(2, num[j+1][i-1]) % mod;
dp[i] %= mod;
}
}
llint ans = dp[n];
ans *= mul, ans %= mod;
ans *= 2, ans %= mod;
cout << ans << endl;
return 0;
} |
#include<algorithm>
#include<stdio.h>
using namespace std;
typedef long long ll;
const int P=1e9+7,N=105;
inline int fpow(int a,int t){
static int r;
for(r=1;t;t>>=1,a=(ll)a*a%P)if(t&1)r=(ll)r*a%P;
return r;
}
int n,m,res,h[N],v[N],f[N][N];
inline void inc(int&x,int y){x+=y;x<P?:x-=P;}
int main(){
int i,j,k,t;
scanf("%d",&n);
for(i=1;i<=n;i++)scanf("%d",h+i),v[i]=h[i];
sort(v+1,v+n+1),m=unique(v+1,v+n+1)-v-1;
for(i=1;i<=n;i++)h[i]=lower_bound(v+1,v+m+1,h[i])-v;
for(i=j=1;j<=h[i];j++)f[i][j]=(ll)2*(fpow(2,v[j]-v[j-1]-(j==1))-1)*fpow(2,v[h[i]]-v[j])%P;
f[i][h[i]+1]=2;
for(i=2;i<=n;i++){
for(j=1;j<=h[i-1];j++)inc(f[i][min(j,h[i]+1)],f[i-1][j]);
if(h[i]>h[i-1]){
t=fpow(2,v[h[i]]-v[h[i-1]]);
for(j=1;j<=h[i-1];j++)f[i][j]=(ll)f[i][j]*t%P;
for(j=h[i-1]+1;j<=h[i];j++)f[i][j]=(ll)f[i-1][h[i-1]+1]*2*(fpow(2,v[j]-v[j-1])-1)%P*fpow(2,v[h[i]]-v[j])%P;
}else (f[i][h[i]+1]<<=1)%=P;
inc(f[i][h[i]+1],f[i-1][h[i-1]+1]*2%P);
}
for(i=1;i<=m+1;i++)inc(res,f[n][i]);
printf("%d\n",res);
} |
#include <algorithm>
#include <utility>
#include <cstdio>
#define MOD 1000000007
typedef long long ll;
inline ll quick_pow(ll a, int n)
{
ll res = 1;
while (n)
{
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
int arr[105];
std::pair<ll, ll> work(int l, int r, int h)
{
if (l > r)
return {1, (MOD + 1) / 2};
int pos = std::min_element(arr + l, arr + r + 1) - arr;
ll val = quick_pow(2, arr[pos] - h);
if (l == r)
return {val, val};
auto x = work(l, pos - 1, arr[pos]), y = work(pos + 1, r, arr[pos]);
return {val * x.first % MOD * y.first % MOD,
4 * x.second % MOD * y.second % MOD + (val - 1) * x.first % MOD * y.first % MOD};
}
int main()
{
// freopen("AGC026-D.in", "r", stdin);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", arr + i);
printf("%lld\n", work(0, n - 1, 1).second * 2 % MOD);
return 0;
}
|
#include<bits/stdc++.h>
#define LL long long
using namespace std;
const int N = 105;
int n, h[N];
LL ans = 1, mod = 1e9 + 7;
struct node {
LL x, y;
};
LL fsp(LL a, LL b) {
LL rst = 1;
while(b > 0) {
if(b&1) rst = rst*a%mod;
b = b>>1;
a = a*a%mod;
}
return rst;
}
node solve(int l, int r, LL up) {
int cnt = 0, mi = 1e9 + 5, last = 0;
node rst;
for(int i = l; i <= r; i++)
if(h[i] == mi) cnt++;
else if(h[i] < mi) mi = h[i], cnt = 1;
if(cnt == r - l + 1) {
rst.x = (fsp(2, mi - up) + fsp(2, r - l + 1) - 2 + mod)%mod;
rst.y = fsp(2, mi - up);
return rst;
}
LL c1 = 1, c2 = 1;
for(int i = l; i <= r + 1; i++) {
if(h[i] > mi && !last) last = i;
else if(h[i] == mi || i > r) {
if(!last) continue;
node tmp = solve(last, i - 1, mi);
c1 = c1*(tmp.x + tmp.y)%mod;
c2 = c2*tmp.y%mod;
last = 0;
}
}
c1 = (c1*fsp(2, cnt)%mod + c2*(fsp(2, mi - up) - 2 + mod)%mod)%mod;
c2 = c2*fsp(2, mi - up)%mod;
rst = (node) {c1, c2};
return rst;
}
int main() {
cin>>n;
for(int i = 1; i <= n; i++)
cin>>h[i];
for(int i = 1; i <= n; i++)
if(h[i] > max(h[i - 1], h[i + 1])) {
ans = ans*fsp(2, h[i] - max(h[i - 1], h[i + 1]))%mod;
h[i] = max(h[i - 1], h[i + 1]);
}
node tmp = solve(1, n, 0);
cout<<tmp.x*ans%mod<<endl;
return 0;
} |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<functional>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
#define MOD 1000000007
#define f(i,n) for(int i=0;i<int(n);i++)
#define N (50000)
long long p2[30];
void prpo2(void){
p2[0] = 2;
f(i, 29)p2[i + 1] = (p2[i] * p2[i]) % MOD;
return;
}
long long po2(int x){
long long re = 1;
f(i,30){
if (x % 2 == 1)re = (re*p2[i]) % MOD;
x = x / 2;
}
return re;
}
int main(void){
int n;
set<int>se;
vector<int>v;
int x, y;
long long cc, dd, aa, bb;
long long c[110];
long long d[110];
int a[110];
bool u[110];
f(i, 110){
u[i] = false;
c[i] = -1;
}
prpo2();
scanf("%d", &n);
f(i, n){
scanf("%d", &a[i]);
if (se.count(a[i]) == 0){
v.push_back(a[i]);
se.insert(a[i]);
}
}
v.push_back(0);
sort(v.begin(), v.end(), greater<int>());
f(i, v.size()-1){
f(j, n){
if (a[j] >= v[i])u[j] = true;
else u[j] = false;
}
f(j, n){
if (u[j]){
cc = 2;
dd = 1;
x = j;
y = j;
while (u[y]){
if (c[y] >= 0){
cc *= c[y];
cc = cc%MOD;
aa = ((2 * c[y]) + d[y]) % MOD;
dd *= aa;
dd = dd%MOD;
}
else if (c[y] == -1){
dd *= 2;
dd = dd%MOD;
}
y++;
}
for (int ii = x; ii < y; ii++)c[ii] = -2;
dd = (dd - cc + MOD) % MOD;
c[x] = cc;
d[x] = dd;
j = y;
}
}
aa = po2(v[i] - v[i + 1] - 1);
f(i, n){
if (c[i] >= 0)c[i] = (c[i] * aa) % MOD;
}
}
aa = (c[0] + d[0]) % MOD;
printf("%lld\n", aa);
return 0;
} |
//ΔAGC026D
#include<iostream>
#include<cstdio>
#include<fstream>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<bitset>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef long long LL;
typedef double DB;
const int N = 111;
const int MO = 1e9+7;
const int inf = 2e9;
int mul(int x,int y){
return (LL)x*y%MO;
}
int fpow(int x,int y=MO-2){
if(!y)
return 1;
LL z=fpow(x,y>>1);
z=mul(z,z);
if(y&1)
return mul(z,x);
return z;
}
int n,h[N],f[N][N],g[N][N];
void solve(int w,int l,int r){
int i,j,x=inf,y=0;
for(i=l;i<=r;i=i+1)
x=min(x,h[i]),y=max(y,h[i]);
if(x==y){
f[l][r]=fpow(2,x-w-1);
g[l][r]=(fpow(2,r-l+1)-2+f[l][r]*2%MO)%MO;
return;
}
f[l][r]=1;
g[l][r]=1;
for(i=l;i<=r;i=i+1){
if(h[i]==x){
g[l][r]=mul(g[l][r],2);
continue;
}
for(j=i;j<=r&&h[j+1]>x;j=j+1);
solve(x,i,j);
f[l][r]=mul(f[l][r],f[i][j]*2);
if(i==j)
g[l][r]=mul(g[l][r],g[i][j]*2);
else
g[l][r]=mul(g[l][r],g[i][j]+f[i][j]*2%MO);
i=j;
}
g[l][r]=(g[l][r]-f[l][r]*2%MO+MO)%MO;
f[l][r]=mul(f[l][r],fpow(2,x-w-1));
g[l][r]=(g[l][r]+f[l][r]*2%MO)%MO;
//cout<<l<<' '<<r<<' '<<f[l][r]<<' '<<g[l][r]<<endl;
}
int main()
{
int i;
cin>>n;
for(i=1;i<=n;i=i+1)
cin>>h[i];
solve(0,1,n);
cout<<g[1][n];
return 0;
} |
#include <cstdio>
#include <algorithm>
#define N 102
#define pi pair<int,int>
#define mkp make_pair
#define fi first
#define se second
using namespace std;
const int mod = 1e9 + 7;
int n;
int a[N];
int quick_pow(int ,int);
pi solve(int ,int ,int);
int main(){
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
scanf("%d", a + i);
pi ans = solve(1, n, 0);
printf("%d\n", (1ll * ans.fi + ans.se * 2 % mod) % mod);
return 0;
}
int quick_pow(int x, int y){
int res = 1;
for(; y; y >>= 1, x = 1ll * x * x % mod)
if(y & 1) res = 1ll * res * x % mod;
return res;
}
pi solve(int l, int r, int h){
if(l > r) return mkp(0, 0);
if(l == r) return mkp(0, quick_pow(2, a[l] - h - 1));
int mn = 999999999;
for(int i = l; i <= r; ++i) mn = min(mn, a[i]);
int f[2] = {1, 1};
for(int i = l; i <= r; ++i)
if(a[i] - mn){
int pos = i;
while(pos + 1 <= r && a[pos + 1] - mn) ++pos;
pi res = solve(i, pos, mn);
f[0] = 1ll * f[0] * ((1ll * res.fi + 1ll * res.se * 4 % mod) % mod) % mod;
f[1] = 1ll * f[1] * res.se % mod * 2 % mod; i = pos;
}
else f[0] = 1ll * f[0] * 2 % mod;
f[0] = (f[0] + (1ll * mod - 1ll * f[1] * 2 % mod) % mod) % mod;
f[1] = 1ll * f[1] * quick_pow(2, mn - h - 1) % mod;
return mkp(f[0], f[1]);
} |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<map>
#include<set>
#include<bitset>
using namespace std;
#define REP(i,m,n) for(int i=(int)m ; i < (int) n ; i++ )
#define rep(i,n) REP(i,0,n)
typedef long long ll;
typedef pair<int,int> pint;
typedef pair<ll,int> pli;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
int dx[4]={1,0,-1,0} , dy[4]={0,1,0,-1} ;
ll dp[111][111][2];
int a[111];
ll powmod(ll n,ll k){
ll ret=1;
while(k>0){
if(k&1)ret=ret*n%mod;
n=n*n%mod;
k>>=1;
}
return ret;
}
ll rec(int l,int r,int h,int flag){
if(dp[l][r][flag]!=-1)return dp[l][r][flag];
int mi=inf,ma=0;
REP(i,l,r){
mi=min(mi,a[i]);
ma=max(ma,a[i]);
}
ll ret1,ret2;
ret1=ret2=1;
ll pos=l-1;
REP(i,l,r){
if(a[i]==mi){
ret2=2*ret2%mod;;
if(i-pos>1){
ret1*=rec(pos+1,i,mi,1);
ret2*=(2*rec(pos+1,i,mi,1)+rec(pos+1,i,mi,0));
ret1%=mod;
ret2%=mod;
}
pos=i;
}
}
if(r-pos>1){
ret1=ret1*rec(pos+1,r,mi,1)%mod;
ret2=ret2*(2*rec(pos+1,r,mi,1)+rec(pos+1,r,mi,0))%mod;
}
ret2=(ret2-ret1*2+2*mod)%mod;
return dp[l][r][flag]=flag?ret1*powmod(2,mi-h)%mod:ret2;
}
int main(){
int n;
cin>>n;
rep(i,n)cin>>a[i];
rep(i,n+1)rep(j,n+1)rep(k,2)dp[i][j][k]=-1;
ll ans=rec(0,n,0,0)+rec(0,n,0,1);
cout<<ans%mod<<endl;
return 0;
}
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <fstream>
#include <vector>
#include <bitset>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
const int MAXN = 105;
const ll MOD = 1000000007;
int n;
int h[MAXN];
ll f[MAXN][MAXN][2];
bool vis[MAXN][MAXN][2];
ll power(ll a,ll b)
{
ll res = 1;
while (b)
{
if (b & 1)
(res *= a) %= MOD;
(a *= a) %= MOD;
b >>= 1;
}
return res;
}
ll dfs(int l,int r,bool fl)
{
if (l > r)
return fl;
if (vis[l][r][fl])
return f[l][r][fl];
vis[l][r][fl] = 1;
int H = max(h[l - 1],h[r + 1]),MN = 1e9;
ll res = 1;
for (int i = l;i <= r;i++)
MN = min(MN,h[i]);
int lst = l;
for (int i = l;i <= r;i++)
if (h[i] == MN)
{
(res *= dfs(lst,i - 1,1)) %= MOD;
lst = i + 1;
}
f[l][r][1] = res * dfs(lst,r,1) * 2 % MOD;
lst = l;
res = 1;
for (int i = l;i <= r;i++)
if (h[i] == MN)
{
(res *= (dfs(lst,i - 1,0) + dfs(lst,i - 1,1) * ((i - 1 >= lst) + 1)) * 2) %= MOD;
lst = i + 1;
}
f[l][r][0] = (res * (dfs(lst,r,0) + dfs(lst,r,1) * ((r >= lst) + 1)) - f[l][r][1]) % MOD;
(f[l][r][1] *= power(2,MN - H - 1)) %= MOD;
return f[l][r][fl];
}
int main()
{
scanf("%d",&n);
for (int i = 1;i <= n;i++)
scanf("%d",&h[i]);
printf("%lld\n",(dfs(1,n,0) + dfs(1,n,1) + MOD + MOD) % MOD);
return 0;
} |
#include<cstdio>
#include<cctype>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 100 + 5;
const int mod = 1e9 + 7;
int qpow(int a,int k) { int ans = 1; for(;k > 0;k >>= 1,a = ((ll)a * a) % mod) if(k & 1) ans = ((ll)ans * a) % mod;return ans;}
int h[maxn] , w[maxn] , dp[maxn][maxn];
int main(){
int n;
scanf("%d",&n);
for(int i = 1;i <= n;i++) scanf("%d",h + i) , w[i] = h[i];
sort(w + 1,w + n + 1); int m = unique(w + 1,w + n + 1) - w - 1;
for(int i = 1;i <= n;i++) h[i] = lower_bound(w + 1,w + m + 1,h[i]) - w;
dp[0][0] = 1;
for(int i = 1;i <= n;i++){
for(int j = h[i] + 1;j <= h[i - 1];j++) dp[i][0] = (dp[i][0] + dp[i - 1][j] * 2 % mod) % mod;
dp[i][0] = (dp[i][0] + dp[i - 1][0] * 2 % mod) % mod;
for(int j = 1;j <= h[i];j++){
dp[i][j] = (ll) dp[i - 1][j] * qpow(2,w[h[i]] - w[h[i - 1]]) % mod;
if(h[i - 1] >= j) continue;
if(j > 1) dp[i][j] = (dp[i][j] + (ll)dp[i - 1][0] * (qpow(2,w[j] - w[j - 1]) - 1) % mod * 2 % mod * qpow(2,w[h[i]] - w[j]) % mod) % mod;
else dp[i][j] = (dp[i][j] + (ll)dp[i - 1][0] * (qpow(2,w[j]) - 2) % mod * qpow(2,w[h[i]] - w[j])) % mod;
}
}
int ans = 0;
for(int i = 0;i <= m;i++) ans = (ans + dp[n][i]) % mod;
printf("%d\n",ans);
} |
#include<iostream>
#include<cstdio>
#include<algorithm>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int N=220,P=1e9+7;
int n,m,ans,a[N],b[N],f[N][N];
void chk(int&x){x-=P;x+=(x>>31)&P;}
int qpw(int x,int y){int z=1;for(;y;y>>=1,x=1ll*x*x%P)if(y&1) z=1ll*z*x%P;return z;}
int main(){
//freopen("1.in","r",stdin);
scanf("%d",&n);a[0]=1;b[n+1]=1;
FOR(i,1,n) scanf("%d",&a[i]),b[i]=a[i];
sort(b+1,b+n+2);m=unique(b+1,b+n+2)-b;
FOR(i,0,n) a[i]=lower_bound(b+1,b+m,a[i])-b;
f[0][1]=1;
FOR(i,1,n)FOR(j,1,a[i-1])if(f[i-1][j]){
int x=a[i-1],y=a[i];
if(x>y){
chk(f[i][min(j,y)]+=f[i-1][j]);
if(j>=y) chk(f[i][y]+=f[i-1][j]);
}
else{
if(j<x) chk(f[i][j]+=1ll*qpw(2,b[y]-b[x])*f[i-1][j]%P);
else FOR(k,x,y)
chk(f[i][k]+=2ll*(qpw(2,b[y]-b[k])-(k==y?0:qpw(2,b[y]-b[k+1]))+P)%P*f[i-1][j]%P);
}
}
FOR(j,1,m) chk(ans+=f[n][j]);
cout<<ans<<'\n';
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD=1e9+7;
ll mypow(int x){
ll res=1,ans=2;
while (x>0){
if (x%2==1){
x--;
res*=ans;
res%=MOD;
continue;
}
ans*=ans;
ans%=MOD;
x/=2;
}
return res;
}
int n,a[103];
ll dp[103][103],ans=0;
vector<int>v;
map <int,int> vis;
map <int,int> mp;
int main(){
cin>>n;
for (int i=1;i<=n;i++){
cin>>a[i];
if (vis[a[i]]) continue;
v.push_back(a[i]);
vis[a[i]]=1;
}
v.push_back(0);
sort (v.begin(),v.end());
for (int i=0;i<v.size();i++)
mp[v[i]]=i;
dp[1][0]=(mypow(v[1]-v[0])-2)%MOD*mypow(a[1]-v[1])%MOD;
for (int i=1;i<mp[a[1]];i++) dp[1][i]=2*(mypow(v[i+1]-v[i])-1)%MOD*mypow(a[1]-v[i+1])%MOD;
dp[1][mp[a[1]]]=2;
for (int i=2;i<=n;i++){
if (a[i-1]>=a[i]){
for (int j=0;j<=mp[a[i]];j++) dp[i][j]=dp[i-1][j];
for (int j=mp[a[i]]+1;j<=mp[a[i-1]];j++) dp[i][mp[a[i]]]+=dp[i-1][j];
dp[i][mp[a[i]]]=dp[i][mp[a[i]]]*2%MOD;
}else{
for (int j=0;j<mp[a[i-1]];j++) dp[i][j]=dp[i-1][j]*mypow(a[i]-a[i-1])%MOD;
dp[i][mp[a[i-1]]]=2*dp[i-1][mp[a[i-1]]]*(mypow(v[mp[a[i-1]]+1]-a[i-1])-1)%MOD*mypow(a[i]-v[mp[a[i-1]]+1])%MOD;
for (int j=mp[a[i-1]]+1;j<mp[a[i]];j++) dp[i][j]=dp[i-1][mp[a[i-1]]]*2%MOD*(mypow(v[j+1]-v[j])-1)%MOD*mypow(a[i]-v[j+1])%MOD;
dp[i][mp[a[i]]]=dp[i-1][mp[a[i-1]]]*2%MOD;
}
}
for (int i=0;i<=mp[a[n]];i++) ans+=dp[n][i];
cout<<ans%MOD;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=105,mod=1e9+7;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(!isdigit(ch))
{
if(ch=='-') f=-1;
ch=getchar();
}
while(isdigit(ch))
{
x=(x<<1)+(x<<3)+ch-'0';
ch=getchar();
}
return x*f;
}
inline int ksm(int x,int y)
{
if(y<=0) return 1;//为什么要加这一句？
int res=1;
for(;y;y>>=1,x=(x*x)%mod)if(y&1)res=(res*x)%mod;
return res;
}
int a[N],Has[N],tot,f[N][N],n,ans;
signed main(void)
{
n=read();
f[0][0]=1;
for(int i=1;i<=n;i++)
{
a[i]=read();
Has[++tot]=a[i];
}
sort(Has+1,Has+tot+1);
tot=unique(Has+1,Has+tot+1)-Has-1;
for(int i=1;i<=n;i++)a[i]=lower_bound(Has+1,Has+tot+1,a[i])-Has;
for(int i=1;i<=n;i++)
{
int now=ksm(2,Has[a[i]]-Has[a[i-1]]);
f[i][0]=(f[i-1][0]<<1)%mod;
for(int j=a[i]+1;j<=a[i-1];j++)f[i][0]=(f[i][0]+((f[i-1][j])<<1)%mod)%mod;
for(int j=1;j<=min(a[i-1],a[i]);j++)f[i][j]=f[i-1][j]*now%mod;
for(int j=a[i-1]+1;j<=a[i];j++)
if(j==1)f[i][j]=f[i-1][0]*(ksm(2,Has[j])-2)%mod*ksm(2,Has[a[i]]-Has[j])%mod;
else f[i][j]=(f[i-1][0]<<1)*(ksm(2,Has[j]-Has[j-1])-1)%mod*ksm(2,Has[a[i]]-Has[j])%mod;
}
for(int i=0;i<=tot;i++)ans=(ans+f[n][i])%mod;
printf("%lld\n",ans);
return 0;
} |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 105;
const int INF = 0x3f3f3f3f;
typedef long long ll;
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
const int MOD = 1e9+7;
int h[N];
int Has[N]; int tot;
ll dp[N][N];
ll Pow(ll x, ll y) {
if(y <= 0) return 1;
ll result = 1;
while(y) {
if(y & 1)
result = result * x % MOD;
y >>= 1;
x = x*x % MOD;
}
return result;
}
int main() {
int n;
while(~scanf("%d", &n)) {
tot = 0;
memset(dp, 0, sizeof(dp));
h[0] = 0;
dp[0][0] = 1;
for(int i = 1; i <= n; ++i) {
scanf("%d", &h[i]);
Has[++tot] = h[i];
}
sort(Has + 1, Has + tot + 1);
tot = unique(Has+1, Has + tot + 1) - Has - 1;
for(int i = 1; i <= n; ++i) {
h[i] = lower_bound(Has + 1, Has + tot + 1, h[i]) - Has;
}
for(int i = 1; i <= n; ++i) {
dp[i][0] = dp[i-1][0] * 2 % MOD;
for(int j = h[i] + 1; j <= h[i-1]; ++j) dp[i][0] = (dp[i][0] + dp[i-1][j] * 2 % MOD) % MOD;
ll tmpPow = Pow(2, Has[h[i]] - Has[h[i-1]]);
for(int j = 1; j <= min(h[i-1], h[i]) ; ++j) {
dp[i][j] = dp[i-1][j] * tmpPow % MOD;
}
for(int j = h[i-1] + 1; j <= h[i]; ++j) {
dp[i][j] = (dp[i][j] + j==1? ( dp[i-1][0] * ( Pow(2, Has[j]) - 2) % MOD * Pow(2, Has[h[i]] - Has[j]) % MOD ) :
( dp[i-1][0] * 2 * (Pow(2, Has[j]-Has[j-1]) - 1) % MOD * Pow(2, Has[h[i]]-Has[j]) % MOD )
) %MOD;
}
}
ll result = 0;
for(int i = 0; i <= tot; ++i) {
result = (result + dp[n][i]) % MOD;
}
printf("%lld\n", result);
}
return 0;
} |
#include<bits/stdc++.h>
#define llong long long
#define mkpr make_pair
#define riterator reverse_iterator
#define pll pair<llong,llong>
using namespace std;
inline int read()
{
int x = 0,f = 1; char ch = getchar();
for(;!isdigit(ch);ch=getchar()) {if(ch=='-') f = -1;}
for(; isdigit(ch);ch=getchar()) {x = x*10+ch-48;}
return x*f;
}
const int mxN = 100;
const int INF = 1e9;
const int P = 1e9+7;
int a[mxN+3];
int n;
llong quickpow(llong x,llong y)
{
llong cur = x,ret = 1ll;
for(int i=0; y; i++)
{
if(y&(1ll<<i)) {y-=(1ll<<i); ret = ret*cur%P;}
cur = cur*cur%P;
}
return ret;
}
pll dfs(int l,int r,int h)
{
// printf("l=%d r=%d h=%d\n",l,r,h);
int h2 = INF; for(int i=l; i<=r; i++) h2 = min(h2,a[i]);
pll ret(0ll,1ll); int mncnt = 0ll,segcnt = 0ll; llong prod1 = 1ll;
for(int i=l,j=l; i<=r+1; i++)
{
if(a[i]==h2||i==r+1)
{
if(j<=i-1)
{
pll tmp = dfs(j,i-1,h2);
ret.second = ret.second*tmp.second%P;
prod1 = prod1*(tmp.first+tmp.second*2ll)%P;
segcnt++;
}
if(i<=r)
{
mncnt++;
}
j = i+1;
}
}
ret.first = (prod1*quickpow(2ll,mncnt)-ret.second*2ll%P+P)%P;
ret.second = ret.second*quickpow(2ll,h2-h)%P;
// printf("(%lld,%lld)\n",ret.first,ret.second);
return ret;
}
int main()
{
scanf("%d",&n);
for(int i=1; i<=n; i++) scanf("%lld",&a[i]);
pll ans = dfs(1,n,0);
printf("%lld\n",(ans.first+ans.second)%P);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define N 110
#define mod 1000000007
typedef long long ll;
ll h[N],a[N],dp[N][N];
inline ll Pow(ll a,ll b,int p=mod) {
if (b<=0) return 1; ll res=1;
for (;b;b>>=1,a=1LL*a*a%p)
if (b&1) res=1LL*res*a%p;
return res;
}
inline int read() {
int x=0;
char ch=getchar();
while (!isdigit(ch)) ch=getchar();
while (isdigit(ch)) x=x*10+ch-'0',ch=getchar();
return x;
}
int main() {
int n=read(),tot=0; dp[0][0]=1;
for (int i=1;i<=n;i++) a[++tot]=h[i]=read();
sort(a+1,a+tot+1),tot=unique(a+1,a+tot+1)-a-1;
for (int i=1;i<=n;i++) h[i]=lower_bound(a+1,a+tot+1,h[i])-a;
for (int i=1;i<=n;i++) {
dp[i][0]=dp[i-1][0]*2%mod;
for (int j=h[i]+1;j<=h[i-1];j++) dp[i][0]=(dp[i][0]+dp[i-1][j]*2%mod)%mod;
ll tmp=Pow(2,a[h[i]]-a[h[i-1]]);
for (int j=1;j<=min(h[i-1],h[i]);j++) dp[i][j]=dp[i-1][j]*tmp%mod;
for (int j=h[i-1]+1;j<=h[i];j++)
if (dp[i][j]+j==1) dp[i][j]=dp[i-1][0]*(Pow(2,a[j])-2)%mod*Pow(2,a[h[i]]-a[j])%mod;
else dp[i][j]=dp[i-1][0]*2*(Pow(2,a[j]-a[j-1])-1)%mod*Pow(2,a[h[i]]-a[j])%mod;
}
ll res=0;
for (int i=0;i<=tot;i++) res=(res+dp[n][i])%mod;
printf("%lld\n",res);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int Maxn=105,mod=1e9+7;
int h[Maxn];
int ksm(int x,int k){
int ret=1,tmp=x;
while(k){
if(k&1)ret=1ll*ret*tmp%mod;
tmp=1ll*tmp*tmp%mod;k>>=1;
}
return ret;
}
pair<int,int>solve(int l,int r,int lim){
int Min=*min_element(h+l,h+r+1);
int cnt=count(h+l,h+r+1,Min);
pair<int,int>ans=make_pair(1,1);
if(cnt==r-l+1){
ans.first=ksm(2,Min-lim);
ans.second=(ans.first+ksm(2,cnt)-2)%mod;
return ans;
}
vector<pair<int,int>>vec;
for(int i=l;i<=r;i++){
if(h[i]==Min)continue;
int L=i;
while(i<=r&&h[i]>Min)i++;
vec.emplace_back(solve(L,i-1,Min));
}
int f=1,g=1;
for(auto&i:vec){
f=1ll*f*i.first%mod;
g=1ll*g*(i.first+i.second)%mod;
}
ans.second=(1ll*(g-1ll*ksm(2,vec.size())*f)%mod*ksm(2,cnt)+1ll*f*(ksm(2,vec.size()+cnt)-2))%mod;
ans.first=1ll*f*ksm(2,Min-lim)%mod;
ans.second=(ans.second+ans.first)%mod;
return ans;
}
int main(){
int n;scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%d",&h[i]);
cout<<(solve(1,n,0).second+mod)%mod<<"\n";
return 0;
} |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#define fi first
#define se second
#define pi pair<LL,LL>
#define LL long long
using namespace std;
const LL inf=2e9;
const LL mod=1e9+7;
LL n,h[110];
LL pow(LL a,LL b)
{
LL ans=1;
while(b)
{
if(b&1) ans=ans*a%mod;
a=a*a%mod;b>>=1;
}
return ans;
}
pi solve(LL l,LL r,LL k)//l r区间大于k的部分
{
LL Min=inf,cnt=0;pi ans;
for(LL i=l;i<=r;i++)
{
if(h[i]<Min) Min=h[i],cnt=1;
else if(h[i]==Min) cnt++;
}
if(cnt==(r-l+1))//矩形随便算
{
ans.fi=(pow(2,r-l+1)+mod-2)%mod;
ans.se=pow(2,Min-k-1);
return ans;
}
LL re=r-l+1,s0=1,s1=1,last=0;//s0 s1是first second
for(LL i=l;i<=r+1;i++) if(!last&&h[i]>Min) last=i;
else if(last&&(h[i]<=Min||i>r))
{
re-=i-last;
pi tmp=solve(last,i-1,Min);
s0=s0*(tmp.fi+4*tmp.se%mod)%mod;//*4是因为上一行可以取反，当前行亦然，2*2
s1=s1*(2*tmp.se%mod)%mod;
last=0;
}
s0=(s0+mod-s1)%mod;
ans.fi=s0*pow(2,re)%mod;
(ans.fi+=(s1*(pow(2,re)-2+mod)%mod)%mod)%=mod;
ans.se=s1*pow(2,Min-k-1)%mod;
//因为fi可以从两种情况转移过来，se只能从s1转移过来
return ans;
}
int main()
{
scanf("%lld",&n);
for(LL i=1;i<=n;i++) scanf("%lld",&h[i]);
if(n==1)
{
printf("%lld",pow(2,h[1]));
return 0;
}
LL tot=1;
for(LL i=1;i<=n;i++) if(h[i]>h[i-1]&&h[i]>h[i+1])
{
(tot*=pow(2,h[i]-max(h[i-1],h[i+1])))%=mod;
h[i]=max(h[i-1],h[i+1]);
}
pi ans=solve(1,n,0);
printf("%lld",tot*((ans.fi+ans.se*2)%mod)%mod);
} |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#define fi first
#define se second
#define pi pair<LL,LL>
#define LL long long
using namespace std;
const LL inf=2e9;
const LL mod=1e9+7;
LL n,h[110];
LL pow(LL a,LL b)
{
LL ans=1;
while(b)
{
if(b&1) ans=ans*a%mod;
a=a*a%mod;b>>=1;
}
return ans;
}
pi solve(LL l,LL r,LL k)//l r区间大于k的部分
{
LL Min=inf,cnt=0;pi ans;
for(LL i=l;i<=r;i++)
{
if(h[i]<Min) Min=h[i],cnt=1;
else if(h[i]==Min) cnt++;
}
if(cnt==(r-l+1))
{
ans.fi=(pow(2,r-l+1)+mod-2)%mod;
ans.se=pow(2,Min-k-1);
//printf("1:%lld %lld %lld %lld\n",l,r,ans.fi,ans.se);
return ans;
}
LL re=r-l+1,s0=1,s1=1,last=0;
for(LL i=l;i<=r+1;i++) if(!last&&h[i]>Min) last=i;
else if(last&&(h[i]<=Min||i>r))
{
re-=i-last;
pi tmp=solve(last,i-1,Min);
s0=s0*(tmp.fi+4*tmp.se%mod)%mod;
s1=s1*(2*tmp.se%mod)%mod;
last=0;
}
s0=(s0+mod-s1)%mod;
//printf("s:%lld %lld\n",s0,s1);
ans.fi=s0*pow(2,re)%mod;
(ans.fi+=(s1*(pow(2,re)-2+mod)%mod)%mod)%=mod;
ans.se=s1*pow(2,Min-k-1)%mod;
//printf("2:%lld %lld %lld %lld\n",l,r,ans.fi,ans.se);
return ans;
}
int main()
{
scanf("%lld",&n);
for(LL i=1;i<=n;i++) scanf("%lld",&h[i]);
if(n==1)
{
printf("%lld",pow(2,h[1]));
return 0;
}
LL tot=1;
for(LL i=1;i<=n;i++) if(h[i]>h[i-1]&&h[i]>h[i+1])
{
(tot*=pow(2,h[i]-max(h[i-1],h[i+1])))%=mod;
h[i]=max(h[i-1],h[i+1]);
}
pi ans=solve(1,n,0);
printf("%lld",tot*((ans.fi+ans.se*2)%mod)%mod);
} |
#include "iostream"
#include "algorithm"
#include "cstring"
#include "cstdio"
#include "vector"
using namespace std;
#define MAXN 116
#define P 1000000007
int n;
int A[MAXN];
int Pow( int x , int a ) {
int cur = x % P , ans = 1;
while( a ) {
if( a & 1 ) ans = 1ll * ans * cur % P;
cur = 1ll * cur * cur % P , a >>= 1;
}
return ans;
}
pair<int,int> solve( int l , int r , int c ) {
// cout << l << ' ' << r << endl;
if( l > r ) return make_pair( 1 , 0 );
int h = 0x3f3f3f3f;
for( int i = l ; i <= r ; ++ i ) h = min( h , A[i] );
vector<int> pos;
pos.push_back( l - 1 );
for( int i = l ; i <= r ; ++ i ) if( A[i] == h ) pos.push_back( i );
pos.push_back( r + 1 );
int nm = pos.size() - 2;
int re = 1 , tot = 1;
for( int i = 0 ; i < pos.size() - 1 ; ++ i ) {
pair<int,int> ret = solve( pos[i] + 1, pos[i + 1] - 1, h );
re = 1ll * re * ret.first % P , tot = 1ll * tot * ( ret.first + ret.second ) % P;
// cout << l << ' ' << r << ' ' << pos[i] + 1 << ' ' << pos[i + 1] << ' ' << re << ' ' << tot << endl;
}
return make_pair( 1ll * re * Pow( 2 , h - c ) % P , ( 1ll * re * ( Pow( 2 , h - c ) - 2 ) % P + 1ll * Pow( 2 , nm ) * tot % P ) % P );
}
int main() {
cin >> n;
for( int i = 1 ; i <= n ; ++ i ) scanf("%d",&A[i]);
cout << solve( 1 , n , 0 ).second << endl;
} |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const int N = 105;
const int MOD = 1000000007;
int n,m,h[N],w[N];
LL dp[N][N];
int pow_(int x,int y) {///快速幂求 x的y次方
int ans = 1;
if(y > 0) {
while(y) {
if(y % 2)ans = (LL)ans * x % MOD;
x = (LL)x * x % MOD;
y /= 2;
}
}
return ans;
}
int main() {
scanf("%d",&n);
for(int i = 1;i <= n;i ++) {
scanf("%d",&h[i]);
w[++ m] = h[i];
}
sort(w + 1,w + m + 1);///高度排序
m = unique(w + 1,w + m + 1) - w - 1;///离散化 m是离散化后的长度
for(int i = 1;i <= n;i ++) {
h[i] = lower_bound(w + 1,w + m + 1,h[i]) - w;
}
dp[0][0]=1;
for(int i = 1;i <= n;i ++) {
for(int j = h[i] + 1;j <= h[i - 1];j ++)
(dp[i][0] += dp[i - 1][j] * 2 % MOD) %= MOD;
(dp[i][0] += dp[i - 1][0] * 2 % MOD) %= MOD;///交叉或者不交叉
int d = pow_(2,w[h[i]] - w[h[i-1]]);
for(int j = 1;j <= min(h[i - 1],h[i]);j ++) {
dp[i][j] = dp[i - 1][j] * d % MOD;
}
for(int j = h[i - 1] + 1;j <= h[i];j ++) {///比前一列高出的部分
if(j > 1)(dp[i][j] += dp[i - 1][0] * (pow_(2,w[j] - w[j - 1]) - 1) % MOD * 2 % MOD * pow_(2,w[h[i]] - w[j]) % MOD) %= MOD;
else (dp[i][1] += dp[i - 1][0] * (pow_(2,w[1]) - 2) % MOD * pow_(2,w[h[i]] - w[1]) % MOD) %= MOD;///上一列中无重复的乘上化不超过上一列高度中有重复的
}
}
LL ans = 0;
for(int i = 0;i <= m;i++)
(ans += dp[n][i]) %= MOD;
printf("%lld",ans);
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
long long modPow(long long a, long long p){
if(p == 0) return 1;
long long res = modPow(a, p/2);
res = (res * res) % MOD;
if(p%2 == 1) res = (res * a) % MOD;
return res;
}
pair<long long, long long> solve(const vector<int>& h){
if(h.size() == 1){
pair<long long, long long> res;
res.first = modPow(2, h[0]);
res.second = 0;
return res;
}
int minH = h[0];
for(const auto& t : h) minH = min(minH, t);
long long alt = 2;
long long any = 0;
for(int i=0;i<h.size();i++){
if(h[i] == minH){
if(i > 0) any = (2 * any + alt) % MOD;
} else {
int end = i;
while(end < h.size() && h[end] != minH) ++end;
vector<int> nh(end - i);
for(int j=i;j<end;j++) nh[j-i] = h[j] - minH;
if(end - i == 1){
auto next = solve(nh);
if(i > 0) any = ((2 * any + alt) * next.first) % MOD;
alt = (alt * next.first) % MOD;
} else {
auto next = solve(nh);
long long addAny = 0;
addAny += (2 * next.first) % MOD;
addAny += next.second % MOD;
any = (any * addAny) % MOD;
if(i > 0){
any = (any + alt * next.first) % MOD;
any = (any + alt * next.second) % MOD;
} else {
any = (any + next.second) % MOD;
}
alt = (alt * next.first) % MOD;
}
i = end - 1;
}
}
alt = (alt * modPow(2, minH-1)) % MOD;
return make_pair(alt, any);
}
int main(){
int N;
while(cin >> N){
vector<int> h(N);
for(auto& t : h) cin >> t;
auto res = solve(h);
cout << (res.first + res.second) % MOD << endl;
}
} |
#include <bits/stdc++.h>
#define N 105
using namespace std;
const int mod = 1e9 + 7;
int n, tot;
int h[N], H[N], f[N][2];
inline int fpm(int x, int y) {
int res = 1;
while(y) {
if(y & 1) res = 1LL * x * res % mod;
x = 1LL * x * x % mod, y >>= 1;
}
return res;
}
void solve(int u, int l, int r) {
bool flag = false;
H[u] = h[r];
for(int i = l; i < r; ++i)
if(h[i] != h[i + 1]) {
H[u] = min(H[u], h[i]);
flag = true;
}
if(!flag) {
f[u][0] = fpm(2, r - l + 1) - 2;
f[u][1] = fpm(2, H[u]);
return;
}
f[u][0] = 1, f[u][1] = 2;
for(int i = l; i <= r; ++i) {
h[i] -= H[u];
if(!h[i])
f[u][0] = (f[u][0] + f[u][0]) % mod;
}
int las = 1;
for(int i = l; i <= r; ++i) {
if(h[i - 1] == 0 && h[i] != 0) las = i;
if(h[i] != 0 && h[i + 1] == 0) {
int v = ++tot;
solve(v, las, i);
f[u][0] = f[u][0] * (f[v][0] + 2LL * f[v][1]) % mod;
f[u][1] = 1LL * f[u][1] * f[v][1] % mod;
}
}
f[u][0] = (f[u][0] - f[u][1] + mod) % mod;
f[u][1] = 1LL * f[u][1] * fpm(2, H[u] - 1) % mod;
// cerr << l << ' ' << r << ' ' << H[u] << ' ' << f[u][0] << ' ' << f[u][1] << endl;
}
int main() {
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
scanf("%d", &h[i]);
solve(0, 1, n);
int ans = (f[0][0] + f[0][1]) % mod;
printf("%d\n", ans);
return 0;
} |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
const int MOD = (int)1e9 + 7;
int n,m,h[101],hnum[101],dh[101];
long long dp[101][101];
int pow_(long long x,int y) {///快速幂求 x的y次方
long long ans = 1;
if(y > 0) {
while(y) {
if(y % 2)ans = ans * x % MOD;
x = x * x % MOD;
y /= 2;
}
}
return ans;
}
int main() {
scanf("%d",&n);
for(int i = 1;i <= n;i ++) {
scanf("%d",&h[i]);
dh[++ m] = h[i];
}
sort(dh + 1,dh + m + 1);///高度排序
m = unique(dh + 1,dh + m + 1) - dh - 1;///离散化 m是离散化后的长度
for(int i = 1;i <= n;i ++) {
hnum[i] = lower_bound(dh + 1,dh + m + 1,h[i]) - dh;
}
dp[0][0]=1;
for(int i = 1;i <= n;i ++) {
for(int j = hnum[i] + 1;j <= hnum[i - 1];j ++)
(dp[i][0] += dp[i - 1][j] * 2 % MOD) %= MOD;
(dp[i][0] += dp[i - 1][0] * 2 % MOD) %= MOD;///交叉或者不交叉
int d = pow_(2,h[i] - h[i - 1]);
for(int j = 1;j <= min(hnum[i - 1],hnum[i]);j ++) {
dp[i][j] = dp[i - 1][j] * d % MOD;
}
for(int j = hnum[i - 1] + 1;j <= hnum[i];j ++) {///比前一列高出的部分
if(j > 1)(dp[i][j] += dp[i - 1][0] * (pow_(2,dh[j] - dh[j - 1]) - 1) % MOD * 2 % MOD * pow_(2,h[i] - dh[j]) % MOD) %= MOD;
else (dp[i][1] += dp[i - 1][0] * (pow_(2,dh[1]) - 2) % MOD * pow_(2,h[i] - dh[1]) % MOD) %= MOD;///上一列中无重复相同的乘上化不超过上一列高度中有重复的
}
}
long long ans = 0;
for(int i = 0;i <= hnum[n];i++)
(ans += dp[n][i]) %= MOD;
printf("%lld",ans);
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
#define N 106
#define mod 1000000007
int dp[N][N],n,s[N],st[N],v[N],v2[N],ct,as=1;
int pw(int a,int p){int as=1;while(p){if(p&1)as=1ll*as*a%mod;a=1ll*a*a%mod;p>>=1;}return as;}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%d",&s[i]),v[i]=s[i];
sort(v+1,v+n+1);
v[0]=1;for(int i=1;i<=n;i++)if(v[i]!=v[i-1])v2[++ct]=v[i];
for(int i=1;i<=n;i++)for(int j=1;j<=ct;j++)if(s[i]==v2[j])st[i]=j;
dp[0][0]=1;
for(int i=1;i<=n;i++)
if(s[i]==1)
{
int su=0;
for(int j=0;j<=ct+1;j++)su=(su+dp[i-1][j])%mod;
as=2ll*as*su%mod;
dp[i][0]=1;
}
else if(s[i-1]<=1)
{
for(int j=1;j<=st[i];j++)
dp[i][j]=pw(2,s[i]-v2[j-1]+(j>1));
dp[i][st[i]+1]=2;
for(int j=1;j<=st[i];j++)dp[i][j]=(dp[i][j]-dp[i][j+1]+mod)%mod;
}
else if(s[i]<=s[i-1])
{
for(int j=1;j<=st[i-1]+1;j++)
if(j>st[i])dp[i][st[i]+1]=(dp[i][st[i]+1]+2ll*dp[i-1][j])%mod;
else dp[i][j]=dp[i-1][j];
}
else
{
for(int j=1;j<=st[i-1];j++)dp[i][j]=1ll*dp[i-1][j]*pw(2,s[i]-s[i-1])%mod;
for(int j=st[i-1]+1;j<=st[i];j++)dp[i][j]=2ll*dp[i-1][st[i-1]+1]*pw(2,s[i]-v2[j-1])%mod;
dp[i][st[i]+1]=2ll*dp[i-1][st[i-1]+1]%mod;
for(int j=st[i-1]+1;j<=st[i];j++)dp[i][j]=(dp[i][j]-dp[i][j+1]+mod)%mod;
}
int su=0;
for(int j=0;j<=ct+1;j++)su=(su+dp[n][j])%mod;
as=1ll*as*su%mod;
printf("%d\n",as);
} |
#include<bits/stdc++.h>
#define y1 dmytxdy
#define fi first
#define se second
#define mp make_pair
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef long double ld;
template <typename T> bool chkmin(T &x,T y){return x>y?x=y,1:0;}
template <typename T> bool chkmax(T &x,T y){return x<y?x=y,1:0;}
int readint(){
int x=0,f=1; char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
const int cys=1000000007;
int n,ncnt;
ll d[105],f[105],a[105];
ll mod(ll x){return x>=cys?x-cys:x;}
ll qpow(ll x,ll p){
ll ret=1;
for(;p;p>>=1,x=x*x%cys) if(p&1) ret=ret*x%cys;
return ret;
}
int solve(int l,int r,int x){
int rt=++ncnt;
if(l==r){
d[rt]=0,f[rt]=qpow(2,a[l]-x);
return rt;
}
ll mina=1<<30;
for(int i=l;i<=r;i++) chkmin(mina,a[i]);
int lst=l-1;
f[rt]=qpow(2,mina-x),d[rt]=1;
for(int i=l;i<=r;i++){
if(a[i]==mina){
d[rt]=mod(d[rt]<<1);
if(lst+1==i){
lst=i;
continue;
}
int tmp=solve(lst+1,i-1,mina);
f[rt]=f[rt]*f[tmp]%cys;
d[rt]=d[rt]*(d[tmp]+(f[tmp]<<1))%cys;
lst=i;
}
}
if(lst!=r){
int tmp=solve(lst+1,r,mina);
f[rt]=f[rt]*f[tmp]%cys;
d[rt]=d[rt]*(d[tmp]+(f[tmp]<<1))%cys;
}
d[rt]=mod(d[rt]+cys-f[rt]*qpow((cys+1)/2,mina-x-1)%cys);
return rt;
}
int main(){
n=readint();
for(int i=1;i<=n;i++) a[i]=readint();
int tmp=solve(1,n,0);
printf("%lld\n",mod(d[tmp]+f[tmp]));
return 0;
} |
#include<cstdio>
#include<algorithm>
#include<cstring>
#define ll long long
using namespace std;
const ll MOD=1e9+7;
int n,sa[105],rnk[105];
ll k,h[105],s[105],f0;
ll quick_pow(ll x,ll a)
{
ll ans=1;
while(a)
{
if(a&1)ans=ans*x%MOD;
x=x*x%MOD;
a>>=1;
}
return ans;
}
bool cmp(int a,int b)
{
return h[a]<h[b];
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%lld",&h[i]);
for(int i=1;i<=n;i++)
{
sa[i]=i;
if(n!=1&&h[i]>max(h[i-1],h[i+1]))
{
k+=h[i]-max(h[i-1],h[i+1]);
h[i]=max(h[i-1],h[i+1]);
}
}
sort(sa+1,sa+n+1,cmp);
for(int i=1;i<=n;i++)rnk[sa[i]]=i;
f0=1;
h[0]=1;
for(int i=1;i<=n;i++)
{
if(rnk[i]<rnk[i-1])f0=(f0*2+(s[rnk[i-1]]-s[rnk[i]]+MOD)*2)%MOD;
else
{
for(int j=1;j<=rnk[i-1];j++)
s[j]=s[j]*quick_pow(2,h[i]-h[i-1])%MOD;
for(int j=rnk[i-1]+1;j<=rnk[i];j++)
s[j]=(s[j-1]+f0*2*(quick_pow(2,h[i]-h[sa[j-1]])-quick_pow(2,h[i]-h[sa[j]])+MOD))%MOD;
f0=f0*2%MOD;
}
}
ll ans=s[rnk[n]]+f0;
ans=ans%MOD*quick_pow(2,k)%MOD;
printf("%lld\n",ans);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int _INT_MAX_ = 0x3fffffff;
const int MOD = int(1e9) + 7;
int fpow(int base, int exp) {
int result = 1;
for (; exp; exp >>= 1) {
if (exp & 1)
result = (long long)result * base % MOD;
base = (long long)base * base % MOD;
}
return result;
}
int n, h[110];
pair<int, int> solve(int l, int r, int limit) {
int min_height = _INT_MAX_;
for (int i = l; i < r; ++i) {
min_height = min(min_height, h[i]);
}
pair<int, int> result = {2, 1};
int tot = -1;
for (int i = l; i <= r; ++i) {
if (i == r || min_height == h[i]) {
++tot;
if (i > l) {
pair<int, int> tmp = solve(l, i, min_height);
result.first = (long long)result.first * tmp.first % MOD;
result.second =
(long long)result.second * (tmp.first + tmp.second) % MOD;
}
l = i + 1;
}
}
result.second = (long long)result.second * fpow(2, tot) % MOD;
result.second = (result.second - result.first + MOD) % MOD;
result.first = (long long)result.first * fpow(2, min_height - limit - 1) % MOD;
result.second = (result.first + result.second) % MOD;
return result;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &h[i]);
}
pair<int, int> ans = solve(0, n, 0);
printf("%d\n", ans.second);
} |
#include<bits/stdc++.h>
#define fi first
#define se second
#define Mp make_pair
#define pb push_back
#define rep(i, j, k) for (int i = (j); i <= (k); i++)
#define per(i, j, k) for (int i = (j); i >= (k); i--)
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int, int> PII;
typedef vector<int> VI;
const int N = 103,mod = 1e9+7,inf=0x3f3f3f3f;
int n,a[N];
int qpow(int a,int b){
int ret=1;
while(b){
if(b&1) ret=(ll)ret*a%mod;
a=(ll)a*a%mod; b>>=1;
}
return ret;
}
PII solve(int l,int r,int h){
if(l==r) {
int x=qpow(2,a[l]-h);
//printf("%d %d %d %d\n",l,a[l],h,x);
return Mp(x,x);
}
int mnh=inf;
rep(i,l,r) mnh=min(mnh,a[i]);
int c=1,t=qpow(2,mnh-h);
rep(i,l,r) if(a[i]==mnh) c=(ll)c*2%mod;
int x=1,y=1;
for(int i = l,j=l; i<=r; i=j+1,j=i){
if(a[i]==mnh) continue;
while(j<r&&a[j+1]!=mnh) j++;
PII ret=solve(i,j,mnh);
x=(ll)x*ret.fi%mod;
y=(ll)y*(ret.fi+ret.se)%mod;
}
int f=(ll)x*t%mod;
int s=((ll)c*y+(ll)(t-2+mod)*x)%mod;
//printf("%d %d %d %d\n",x,y,f,s);
return Mp(f,s);
}
int main(){
scanf("%d",&n);
rep(i,1,n) scanf("%d",&a[i]);
printf("%d\n",solve(1,n,0).se);
return 0;
} |
#include <cstdio>
typedef long long LL;
const int Mod = 1000000007, Phi = Mod - 1, Inv2 = (Mod + 1) / 2;
const int MN = 105;
inline LL pw(LL e) {
e = (e % Phi + Phi) % Phi;
LL b = 2, a = 1;
for (; e; e >>= 1, b = b * b % Mod)
if (e & 1) a = a * b % Mod;
return a;
}
int N, A[MN];
int stk[MN], tp;
LL B[MN], dp[MN];
inline void Add(int i, LL x) {
dp[i] = (dp[i] + x) % Mod;
}
int main() {
scanf("%d", &N), A[0] = A[N + 1] = 1, B[0] = 1;
for (int i = 1; i <= N; ++i) {
scanf("%d", &A[i]);
B[i] = B[i - 1] + (A[i] > A[i - 1] ? A[i] - A[i - 1] : 0);
}
dp[0] = 1, stk[tp = 1] = 0;
for (int i = 1; i <= N + 1; ++i) {
while (tp && A[stk[tp]] >= A[i]) {
int j = stk[tp];
if (j != i - 1) {
int k = stk[tp + 1];
LL num2 = B[i - 1] - B[j];
LL num1 = num2 - (A[k] - A[j]);
Add(i, 4 * (pw(num2) - pw(num1)) * dp[j]);
} else Add(i, 2 * dp[j]);
--tp;
}
if (tp) {
int j = stk[tp];
if (j != i - 1) {
int k = stk[tp + 1];
if (A[k] != A[i]) {
LL num2 = B[i - 1] - B[j] - (A[i] - A[j]);
LL num1 = num2 - (A[k] - A[i]);
Add(i, 4 * (pw(num2) - pw(num1)) * dp[j]);
}
} else Add(i, 2 * dp[j]);
}
stk[++tp] = i;
}
printf("%lld\n", (dp[N + 1] + Mod) * Inv2 % Mod);
return 0;
} |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 105;
const int INF = 0x3f3f3f3f;
typedef long long ll;
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
const int MOD = 1e9+7;
int h[N];
int Has[N]; int tot;
ll dp[N][N];
ll Pow(ll x, ll y) {
if(y <= 0) return 1;
ll result = 1;
while(y) {
if(y & 1)
result = result * x % MOD;
y >>= 1;
x = x*x % MOD;
}
return result;
}
int main() {
int n;
while(~scanf("%d", &n)) {
tot = 0;
memset(dp, 0, sizeof(dp));
h[0] = 0;
dp[0][0] = 1;
for(int i = 1; i <= n; ++i) {
scanf("%d", &h[i]);
Has[++tot] = h[i];
}
sort(Has + 1, Has + tot + 1);
tot = unique(Has+1, Has + tot + 1) - Has - 1;
for(int i = 1; i <= n; ++i) {
h[i] = lower_bound(Has + 1, Has + tot + 1, h[i]) - Has;
}
for(int i = 1; i <= n; ++i) {
dp[i][0] = dp[i-1][0] * 2 % MOD;
for(int j = h[i] + 1; j <= h[i-1]; ++j) dp[i][0] = (dp[i][0] + dp[i-1][j] * 2 % MOD) % MOD;
ll tmpPow = Pow(2, Has[h[i]] - Has[h[i-1]]);
for(int j = 1; j <= h[i]; ++j) {
dp[i][j] = dp[i-1][j] * tmpPow % MOD;
}
for(int j = h[i-1] + 1; j <= h[i]; ++j) {
dp[i][j] = (dp[i][j] + j==1? ( dp[i-1][0] * ( Pow(2, Has[j]) - 2) % MOD * Pow(2, Has[h[i]] - Has[j]) % MOD ) :
( dp[i-1][0] * 2 * (Pow(2, Has[j]-Has[j-1]) - 1) % MOD * Pow(2, Has[h[i]]-Has[j]) % MOD )
) %MOD;
}
}
ll result = 0;
for(int i = 0; i <= tot; ++i) {
result = (result + dp[n][i]) % MOD;
}
printf("%lld\n", result);
}
return 0;
} |
#include<bits/stdc++.h>
#define ll long long
#define mod 1000000007
#define N 105
int n,f[N][N],h[N],w[N],m;
int ksm(int x,int y)
{
int s = 1;
for(int i = y; i > 0; i >>= 1){
if(i & 1) s = 1ll * s * x % mod;
x = 1ll * x * x % mod;
}
return s;
}
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++) scanf("%d",&h[i]),w[++m]=h[i];
std::sort(w+1,w+m+1);
m=std::unique(w+1,w+m+1)-w-1;
for (int i=1;i<=n;i++) h[i]=std::lower_bound(w+1,w+m+1,h[i])-w;
f[0][0]=1;
for (int i=1;i<=n;i++)
{
for (int j=h[i]+1;j<=h[i-1];j++) (f[i][0]+=f[i-1][j]*2%mod)%=mod;
(f[i][0]+=f[i-1][0]*2%mod)%=mod;
for (int j=1;j<=h[i];j++)
{
f[i][j]=(ll)f[i-1][j]*ksm(2,w[h[i]]-w[h[i-1]])%mod;
if (h[i-1]>=j) continue;
if (j>1) (f[i][j]+=(ll)f[i-1][0]*(ksm(2,w[j]-w[j-1])-1)%mod*2%mod*ksm(2,w[h[i]]-w[j])%mod)%=mod;
else (f[i][j]+=(ll)f[i-1][0]*(ksm(2,w[j])-2)%mod*ksm(2,w[h[i]]-w[j])%mod)%=mod;
}
}
int ans=0;
for (int i=0;i<=m;i++) (ans+=f[n][i])%=mod;
printf("%d",ans);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
int add(int x, int y) {
x += y;
if (x >= mod) {
x -= mod;
}
return x;
}
int sub(int x, int y) {
x -= y;
if (x < 0) {
x += mod;
}
return x;
}
int mul(int x, int y) {
return (ll)x * y % mod;
}
int power(int x, int y) {
int result = 1;
for (; y; y >>= 1, x = mul(x, x)) {
if (y & 1) {
result = mul(result, x);
}
}
return result;
}
pair<int, int> solve(int l, int r, int base, vector<int> &a) {
int x = *min_element(a.begin() + l, a.begin() + r), coef = 1, all = 1, number = 0;
for (int i = l; i < r; ++i) {
if (a[i] != x) {
int j = i;
while (j + 1 < r && a[j + 1] != x) {
++j;
}
pair<int, int> value = solve(i, j + 1, x, a);
i = j;
coef = mul(coef, value.first);
all = mul(all, add(value.first, value.second));
} else {
++number;
}
}
return make_pair(mul(coef, power(2, x - base)), add(mul(all, power(2, number)), mul(coef, sub(power(2, x - base), 2))));
}
int main() {
#ifdef wxh010910
freopen("input.txt", "r", stdin);
#endif
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
printf("%d\n", solve(0, n, 0, a).second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll p = 1e9+7;
ll n, h[105], dp[105][105], k;
map<int, int> m;
vector<int> v;
ll exp(ll x, ll k) {
if (k < 0)
return 0;
if (k == 0)
return 1;
if (k%2 == 1)
return x*exp(x, k-1)%p;
ll y = exp(x, k/2);
return y*y%p;
}
//alternate in first h1 squares
//does not alternate in first h2 squares
//total length x
ll ctalt(ll h1, ll h2, ll x) {
if (h1 >= h2)
return 0;
ll ct1 = 0, ct2 = 0;
if (h1 == 0)
ct1 = exp(2, x);
else
ct1 = 2*exp(2, x-h1);
if (h2 == 0)
ct2 = exp(2, x);
else
ct2 = 2*exp(2, x-h2);
return (p+ct1%p-ct2%p)%p;
}
int main() {
cin >> n;
v.push_back(0);
for (int i = 0; i < n; ++i) {
cin >> h[i];
if (m.count(h[i]) > 0)
continue;
m[h[i]] = 1;
v.push_back(h[i]);
}
sort(v.begin(), v.end());
k = v.size();
v.push_back(1000000005);
for (int i = 0; i < n; ++i) {
if (i == 0) {
for (int j = 0; j < k; ++j) {
dp[i][j] = ctalt(v[j], v[j+1], h[i]);
}
continue;
}
int t = 0, t1 = 0;
for (int j = 0; j < k; ++j) {
if (h[i] == v[j])
t = j;
if (h[i-1] == v[j])
t1 = j;
}
for (int j = 0; j <= t1; ++j) {
if (h[i] <= h[i-1]) {
if (v[j] >= h[i])
dp[i][t] = (dp[i][t] + 2*dp[i-1][j])%p;
else
dp[i][j] = (dp[i][j] + dp[i-1][j])%p;
} else {
if (j < t1) {
dp[i][j] = (dp[i][j] + dp[i-1][j]*exp(2, h[i]-h[i-1]))%p;
} else {
ll x = dp[i-1][j];
for (int jj = t1; jj < k; ++jj)
dp[i][jj] = (dp[i][jj] + x*ctalt(v[jj], v[jj+1], h[i]))%p;
}
}
}
}
ll ans = 0;
for (int j = 0; j < k; ++j)
ans = (ans + dp[n-1][j])%p;
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110, P = 1000000007;
int n, a[maxn];
int qp(int x, int y) {
int z = 1;
for (; y; y >>= 1, x = 1LL * x * x % P) {
if (y & 1) z = 1LL * z * x % P;
}
return z;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
function<pair<int, int>(int, int, int)> solve = [&](int l, int r, int lst) {
int x = *min_element(a + l, a + r + 1);
int coef = 1, sum = 1, num = r - l + 1;
for (int i = l, j; i <= r; i++) if (a[i] ^ x) {
for (j = i; a[j] ^ x && j <= r; j++) num--;
auto p = solve(i, j - 1, x); i = j;
coef = 1LL * coef * p.first % P;
sum = 1LL * sum * (p.first + p.second) % P;
}
return pair<int, int>(1LL * coef * qp(2, x - lst) % P,
(1LL * sum * qp(2, num) + 1LL * coef * (qp(2, x - lst) - 2) % P) % P);
};
auto p = solve(1, n, 0);
printf("%d\n", (p.second + P) % P);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int N;
int H[105];
ll mo=1000000007;
ll modpow(ll a, ll n = mo-2) {
ll r=1;a%=mo;
while(n) r=r*((n%2)?a:1)%mo,a=a*a%mo,n>>=1;
return r;
}
pair<ll,ll> hoge(int L,int R,int v) {
ll dp1=1,dp2=1;
int i;
if(L>R) return {0,0};
int mi=1<<30;
for(i=L;i<=R;i++) mi=min(mi,H[i]);
int W=R-L+1;
for(i=L;i<=R;i++) if(mi!=H[i]) W--;
int pre=L-1;
for(i=L;i<=R;i++) {
if(mi==H[i]) {
auto r=hoge(pre+1,i-1,mi);
if(r.first>0) {
(dp1*=r.first)%=mo;
(dp2*=r.first+r.second)%=mo;
}
pre=i;
}
}
auto r=hoge(pre+1,R,mi);
if(r.first > 0) {
(dp1*=r.first)%=mo;
(dp2*=r.first+r.second)%=mo;
}
(dp2=dp2*modpow(2,W)+(modpow(2,mi-v)+mo-2)*dp1)%=mo;
(dp1*=modpow(2,mi-v))%=mo;
return {dp1,dp2};
}
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N;
for(i=1;i<=N;i++) cin>>H[i];
cout<<hoge(1,N,0).second<<endl;
}
int main()
{
solve();
} |
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1e5+5;
const int mod=1e9+7;
int n,a[N],foo[N],bar[N];
int fp(int x){
return 1ll*foo[x%N]*bar[x/N]%mod;
}
pair<int,int>solve(int l,int r,int h){
int mn=1<<30,cnt=0,x=1,y=1;
for(int i=l;i<=r;++i)
if(a[i]<mn)mn=a[i],cnt=1;
else if(a[i]==mn)++cnt;
if(cnt==r-l+1)
x=fp(r-l+1)-2,y=fp(mn-h);
else{
int z=r-l+1;
for(int i=l,j=0;i<=r;++i){
if(!j&&a[i]>mn)j=i;
if(j&&(i==r||a[i+1]==mn)){
auto res=solve(j,i,mn);
x=(res.first+2ll*res.second)*x%mod;
y=1ll*res.second*y%mod;
z-=i-j+1;j=0;
}
}
x=(x+mod-y)%mod;
x=(1ll*x*fp(z)+1ll*y*(fp(z)-2))%mod;
y=1ll*y*fp(mn-h)%mod;
}
return make_pair(x,y);
}
int main(){
foo[0]=1;foo[1]=2;
for(int i=2;i<N;++i)foo[i]=1ll*foo[i-1]*foo[1]%mod;
bar[0]=1;bar[1]=(foo[N-1]<<1)%mod;
for(int i=2;i<N;++i)bar[i]=1ll*bar[i-1]*bar[1]%mod;
scanf("%d",&n);
for(int i=1;i<=n;++i)scanf("%d",&a[i]);
auto ans=solve(1,n,0);
printf("%d\n",(ans.first+ans.second)%mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define TWO 500000004
int n, x[105], par[105], ta, tc;
set<int> m;
set<int>::iterator it;
long long ya[105], yb[105], tb;
int find(int a) {
return par[a] == a ? a : par[a] = find(par[a]);
}
long long po(long long b, int p) {
long long re = 1;
while (p) {
if (p & 1)
re = re * b % MOD;
b = b * b % MOD;
p >>= 1;
}
return re;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", x + i);
m.insert(x[i]);
}
m.insert(1);
it = m.end();
while (it != m.begin()) {
it--;
ta = *it;
for (int i = 1; i <= n; i++)
if (par[i]) {
if (par[i] == i) {
yb[i] = yb[i] * po(2, x[i] - ta) % MOD;
x[i] = ta;
if (par[i - 1]) {
tc = find(i - 1);
tb = yb[tc] * yb[i] % MOD * TWO % MOD;
ya[tc] = ((ya[tc] + yb[tc]) * (ya[i] + yb[i]) % MOD + MOD - tb) % MOD;
yb[tc] = tb;
par[i] = tc;
}
}
} else if (x[i] == ta) {
if (par[i - 1]) {
tc = find(i - 1);
ya[tc] = (ya[tc] * 2 + yb[tc]) % MOD;
par[i] = tc;
} else {
par[i] = i;
yb[i] = 2;
}
}
// printf("[%d]\n", ta);
// for (int i = 1; i <= n; i++) if (par[i] == i) printf("%d %lld %lld\n", i, ya[i], yb[i]);
}
printf("%lld\n", (ya[1] + yb[1]) % MOD);
return 0;
}
|
#include <bits/stdc++.h>
typedef long long int int64;
static const int64 mod = 1000000007LL;
int64 pow2(int x)
{
int64 val = 1;
for(int i = 30;i >= 0;--i) {
val = val * val % mod;
if(((x >> i) & 1) == 1) {
val = val * 2 % mod;
}
}
return val;
}
std::pair<int64,int64> solve(std::vector<int> h)
{
if(h.empty()) return std::make_pair(1,1);
int min = h[0];
for(int i = 1;i < h.size();++i) if(h[i] < min) min = h[i];
std::vector<int> cur;
int64 v1 = 1, v2 = 1;
int w = 0;
for(int i = 0;i <= h.size();++i) {
if(i == h.size() || h[i] == min) {
if(!cur.empty()) {
std::pair<int64,int64> res = solve(cur);
v1 = v1 * res.first % mod;
v2 = v2 * (res.first + res.second) % mod;
cur.clear();
}
++w;
} else {
cur.push_back(h[i] - min);
}
}
--w;
return std::make_pair(v1*pow2(min)%mod, (v2*pow2(w)+(pow2(min)-2)*v1)%mod);
}
int main()
{
int n;
std::vector<int> h;
scanf("%d",&n);
for(int i = 0;i < n;++i) {
int k;
scanf("%d",&k);
h.push_back(k);
}
std::pair<int64,int64> ans = solve(h);
printf("%lld\n", ans.second);
}
|
#include<cstdio>
#include<utility>
#include<map>
#include<algorithm>
using namespace std;
const long long mod = 1000000007;
typedef pair<int, int> P;
map<P, long long> mp;
int a[110];
int N;
int vals[110];
long long mul(long long a, long long b){
return (a * b) % mod;
}
long long ex(long long a, long long e){
if(e == 0) return 1;
long long tmp = ex(a, e / 2);
tmp = mul(tmp, tmp);
if(e % 2 == 1) tmp = mul(tmp, a);
return tmp;
}
long long dp[110];
long long solve(){
for(int i = 1; i <= N; ++i){
int ub = a[i];
for(int j = i; j <= N; ++j){
ub = min(ub, a[j]);
int lb = max(a[i - 1], a[j + 1]);
if(lb == 0) lb = 1;
if(ub > lb){
mp[P(i, j)] = ub - lb;
}
}
}
dp[0] = 1;
for(int i = 1; i <= N; ++i){
long long e = 0;
for(int j = i - 1; j >= 0; --j){
for(int k = j + 1; k <= i; ++k){
e += mp[P(j + 1, k)];
}
dp[i] += mul(dp[j], ex(2, e));
dp[i] %= mod;
}
}
long long ans = mul(dp[N], 2);
ans += mod;
ans %= mod;
return ans;
}
void input(){
scanf("%d", &N);
for(int i = 1; i <= N; ++i){
scanf("%d", a + i);
}
}
int main(){
input();
long long ans = solve();
printf("%lld\n", ans);
return 0;
}
|
#include<cstdio>
#include<algorithm>
#define int long long
#define mod 1000000007
int a[110],n;
struct node{
int x,y;
};
int quickpow(int x,int y){
if(y==0)return 1;
if(y==1)return x;
if(y%2==0)return quickpow(x*x%mod,y/2);
if(y%2==1)return quickpow(x*x%mod,y/2)*x%mod;
}
node calc(int l,int r,int lim){
int minn=0x3f3f3f3f3f3f3f3f,cnt=0;
node ans;
for(int i=l;i<=r;i++)
if(a[i]<minn)minn=a[i],cnt=1;
else if(a[i]==minn)cnt++;
if(cnt==r-l+1){
ans.x=(quickpow(2,r-l+1)-2+mod)%mod;
ans.y=quickpow(2,minn-lim-1);
return ans;
}
int s0=1,s1=1,last=0;
for(int i=l;i<=r+1;i++){
if(!last&&a[i]>minn)last=i;
else if(last&&(i==r+1||a[i]==minn)){
node Ans=calc(last,i-1,minn);
(s0*=(Ans.x+4*Ans.y%mod)%mod)%=mod;
(s1*=Ans.y*2%mod)%=mod;
last=0;
}
}
s0=(s0+mod-s1)%mod;
ans.x=(s0*quickpow(2,cnt)%mod+s1*(quickpow(2,cnt)-2+mod)%mod)%mod;
ans.y=s1*quickpow(2,minn-lim-1)%mod;
return ans;
}
signed main(){
scanf("%lld",&n);
for(int i=1;i<=n;i++)
scanf("%lld",&a[i]);
if(n==1){
printf("%lld",quickpow(2,a[1]));
return 0;
}
int ans=1;
for(int i=1;i<=n;i++)
if(a[i]>a[i-1]&&a[i]>a[i+1]){
(ans*=quickpow(2,a[i]-std::max(a[i+1],a[i-1])))%=mod;
a[i]=std::max(a[i+1],a[i-1]);
}
node Ans=calc(1,n,0);
printf("%lld\n",ans*(Ans.x+2*Ans.y%mod)%mod);
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pll = pair<ll,ll>;
#define f(i,a,b) for (int i = a; i < b; i++)
#define pb push_back
#define Min(a,b) a=min(a,b)
const int mod = 1e9+7;
ll modpow(ll a, ll b) {
return b?modpow(a*a%mod,b/2)*(b&1?a:1)%mod:1;
}
pll solve(vi ds) {
int x = mod;
f(i,0,ds.size()) Min(x,ds[i]);
int w = 0;
ll a = 1, b = 1;
vi nxt;
f(i,0,ds.size()) if (x == ds[i]) {
if (nxt.size()) {
pll sol = solve(nxt);
a = a*sol.first%mod;
b = b*((sol.first+sol.second)%mod)%mod;
nxt = vi();
}
w++;
} else nxt.pb(ds[i]-x);
if (nxt.size()) {
pll sol = solve(nxt);
a = a*sol.first%mod;
b = b*((sol.first+sol.second)%mod)%mod;
}
return pll(a*modpow(2,x)%mod,
(b*modpow(2,w)%mod+(modpow(2,x)+mod-2)*a%mod)%mod);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
clock_t start = clock();
#endif
int n;
cin>>n;
vi ds(n);
f(i,0,n) cin>>ds[i];
cout << solve(ds).second << endl;
#ifdef LOCAL
cout << setprecision(12) << (long double)(clock()-start) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
|
#include <bits/stdc++.h>
const long long inv2=500000004;
const int N=105,mu=1000000007;
int h[N],b[N],dp[N],dp2[N],f[N],n;
bool cmp(int x,int y){
return h[x]==h[y]?x<y:h[x]>h[y];
}
int find(int x){
if (f[x]==x) return f[x];
f[x]=find(f[x]);
return f[x];
}
int ksm(int x,int y){
int ans=1;
for (;y;y>>=1,x=1ll*x*x%mu)
if (y&1) ans=ans*1ll*x%mu;
return ans;
}
void merge(int x,int y){
int fx=find(x),fy=find(y);
if (fx==fy) return;
int t2=ksm(2,h[fy]-h[fx])*1ll*dp2[fy]%mu;
dp[fx]=(1ll*dp[fx]*(t2+dp[fy])%mu+1ll*dp2[fx]*dp[fy]%mu)%mu;
dp2[fx]=inv2*t2%mu*dp2[fx]%mu;
dp[fx]=(dp[fx]+dp2[fx])%mu;
f[fy]=fx;
}
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++) scanf("%d",&h[i]);
for (int i=1;i<=n;i++) b[i]=i;
std::sort(b+1,b+n+1,cmp);
for (int i=1;i<=n;i++) dp2[i]=2,dp[i]=0,f[i]=i;
for (int j=1;j<=n;j++){
int i=b[j];
if (h[i-1]>=h[i]) merge(i,i-1);
if (h[i+1]>=h[i]) merge(i,i+1);
}
int ff=find(1);
printf("%d",(dp[ff]+1ll*dp2[ff]*ksm(2,h[ff]-1))%mu);
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 105;
const int MOD = 1e9 + 7;
int n, h[N];
int qpow(int x, int k) {
int r = 1;
while(k) {
if(k & 1) r = (ll)r * x % MOD;
x = (ll)x * x % MOD;
k >>= 1;
}
return r;
}
typedef pair<int, int> pii;
pii dfs(int l, int r) {
int mn = 2e9, mc = 0;
for(int i = l; i <= r; i++) {
if(h[i]) {
if(mn == h[i]) mc++;
else if(mn > h[i]) mc = 1;
mn = min(mn, h[i]);
}
}
// printf("mc:%d mn:%d\n", mc, mn);
vector<pii> res;
int st = -1, t = 0;
for(int i = l; i <= r; i++) {
h[i] -= mn;
if(h[i]) {
if(st == -1) st = i, t = 1;
else {
t++;
}
} else {
if(t) {
res.push_back(dfs(st, st + t - 1));
t = 0;
st = -1;
}
}
}
if(t) {
res.push_back(dfs(st, st + t - 1));
}
ll o1 = qpow(2, mc), o2 = qpow(2, mn);
ll r1 = o1, r11 = o2 - 2, ret2 = o2;
for(pii p : res) {
ret2 = ret2 * p.second % MOD;
r1 = r1 * (p.first + p.second) % MOD;
r11 = r11 * p.second % MOD;
}
// printf("%d %d mn:%d mc:%d ret1:%d ret2:%d\n", l, r, mn, mc, ret1, ret2);
return pii((r1 + r11) % MOD, ret2);
}
int main() {
int n;
cin >> n;
for(int i = 0; i < n; i++) {
cin >> h[i];
}
pii res = dfs(0, n - 1);
cout << res.first % MOD << endl;
return 0;
} |
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010,mod=1e9+7;
int n,ans=1,x,y,high[N];
int power(int p)
{
int ans=1,v=2;
for(;p;p>>=1,v=1ll*v*v%mod)
if(p&1)ans=1ll*ans*v%mod;
return ans;
}
void slove(int l,int r,int h,int &a,int &b)
{
int minf=0x7fffffff,cnt=0;
for(int i=l;i<=r;i++)
if(high[i]<minf)minf=high[i],cnt=1;
else if(high[i]==minf)cnt++;
if(cnt==r-l+1)
{
a=power(r-l+1)-2;if(a<0)a+=mod;
b=power(minf-h);
return;
}
int x,y,last=0,v1=1,v2=1;
for(int i=l;i<=r+1;i++)
{
if(!last&&high[i]>minf)last=i;
else if(last&&(high[i]<=minf||i==r+1))
{
slove(last,i-1,minf,x,y);
v1=1ll*v1*(x+y*2%mod)%mod;
v2=1ll*v2*y%mod;last=0;
}
}
a=1ll*v1*power(cnt)%mod;
a=(a-v2*2)%mod;if(a<0)a+=mod;
b=1ll*v2*power(minf-h)%mod;
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&high[i]);
for(int i=1;i<=n;i++)
if(high[i]>high[i-1]&&high[i]>high[i+1])
{
ans=1ll*ans*power(high[i]-max(high[i-1],high[i+1]))%mod;
high[i]=max(high[i-1],high[i+1]);
}
slove(1,n,0,x,y);
ans=1ll*ans*(x+y)%mod;
printf("%d\n",ans);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int M=1e9+7;
int a[110],n;
struct node{
int x,y;
};
int ksm(int x,int y){
int ans=1;
for (;y;y>>=1,x=x*x%M)
if (y&1)(ans*=x)%=M;
return ans;
}
node calc(int l,int r,int lim){
int minn=1e18,cnt=0;
node ans;
for (int i=l;i<=r;i++)
if (a[i]<minn)minn=a[i],cnt=1;
else if (a[i]==minn)cnt++;
if (cnt==r-l+1){
ans.x=(ksm(2,r-l+1)-2+M)%M;
ans.y=ksm(2,minn-lim-1);
return ans;
}
int s0=1,s1=1,last=0;
for (int i=l;i<=r+1;i++){
if (!last&&a[i]>minn)last=i;
else if (last&&(i==r+1||a[i]==minn)){
node Ans=calc(last,i-1,minn);
(s0*=(Ans.x+4*Ans.y%M)%M)%=M;
(s1*=Ans.y*2%M)%=M;
last=0;
}
}
s0=(s0+M-s1)%M;
ans.x=(s0*ksm(2,cnt)%M+s1*(ksm(2,cnt)-2+M)%M)%M;
ans.y=s1*ksm(2,minn-lim-1)%M;
return ans;
}
signed main(){
scanf("%lld",&n);
for (int i=1;i<=n;i++)scanf("%lld",&a[i]);
if (n==1){
printf("%lld",ksm(2,a[1]));
return 0;
}
int ans=1;
for (int i=1;i<=n;i++)
if (a[i]>a[i-1]&&a[i]>a[i+1]){
(ans*=ksm(2,a[i]-max(a[i+1],a[i-1])))%=M;
a[i]=max(a[i+1],a[i-1]);
}
node Ans=calc(1,n,0);
printf("%lld\n",ans*(Ans.x+2*Ans.y%M)%M);
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll MOD = 1e9+7;
int n;
ll h[110];
ll power(ll a, ll n) {
if (n<0) return 0;
if (!n) return 1;
ll t = power(a,n/2);
return t*t%MOD*((n&1)?a:1)%MOD;
}
ll D[110][110];
ll ch[110];
vector<ll> comp;
int main() {
int i, j;
scanf("%d",&n);
for (i=0;i<n;i++) scanf("%lld",&h[i]);
for (i=0;i<n;i++) comp.push_back(h[i]);
comp.push_back(0);
sort(comp.begin(),comp.end());
comp.erase(unique(comp.begin(),comp.end()),comp.end());
for (i=0;i<n;i++) ch[i] = lower_bound(comp.begin(),comp.end(),h[i])-comp.begin();
for (j=0;j<comp.size();j++) {
if (j==0) D[0][j] = power(2,h[0]);
else if (j<=ch[0]) D[0][j] = power(2,h[0]-comp[j]+1);
else D[0][j] = 0;
}
for (i=1;i<n;i++) {
ll p = min(ch[i-1],ch[i]);
for (j=0;j<comp.size();j++) {
if (j<=p) D[i][j] = (D[i-1][j]+D[i-1][p])*power(2,h[i]-comp[p])%MOD;
else D[i][j] = D[i-1][p]*2*power(2,h[i]-comp[j])%MOD;
}
}
printf("%lld\n",D[n-1][0]);
return 0;
}
|
#pragma GCC optimize(3)
#include<bits/stdc++.h>
#define MAXN 100005
#define INF 1000000000
#define MOD 1000000007
#define F first
#define S second
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int n,h[MAXN];
void add(int &a,int b) {a+=b; if(a>=MOD) a-=MOD;}
void dec(int &a,int b) {a-=b; if(a<0) a+=MOD;}
int pow_mod(int a,int i)
{
int s=1;
while(i)
{
if(i&1) s=1LL*s*a%MOD;
a=1LL*a*a%MOD;
i>>=1;
}
return s;
}
P solve(int l,int r)
{
int minh=INF;
for(int i=l;i<=r;i++) minh=min(minh,h[i]);
int cnt=0;
for(int i=l;i<=r;i++)
{
h[i]-=minh;
if(!h[i]) cnt++;
}
int ans1=1,ans2=1;
int lb=INF,rb=-INF;
for(int i=l;i<=r;i++)
{
if(h[i]==0)
{
if(rb!=-INF)
{
P p=solve(lb,rb);
ans1=1LL*ans1*p.F%MOD;
ans2=1LL*ans2*(p.F+p.S)%MOD;
}
lb=INF;rb=-INF;
}
else
{
lb=min(lb,i);
rb=max(rb,i);
}
}
if(rb!=-INF)
{
P p=solve(lb,rb);
ans1=1LL*ans1*p.F%MOD;
ans2=1LL*ans2*(p.F+p.S)%MOD;
}
ans2=1LL*ans2*pow_mod(2,cnt)%MOD;
int mult=pow_mod(2,minh);
dec(ans2,2LL*ans1%MOD); ans1=1LL*ans1*mult%MOD; add(ans2,ans1);
return P(ans1,ans2);
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&h[i]);
printf("%d\n",solve(1,n).S);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int n,a,b,c;
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d%d%d",&a,&b,&c);
b=max(b,-b),c=max(c,-c);
if((b+c)%2!=a%2)
{
cout<<"No\n";
return 0;
}
if(b+c>a)
{
cout<<"No\n";
return 0;
}
}
cout<<"Yes\n";
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int n,t,x,y;
int main(){
cin>>n;
while(n--){
cin>>t;
cin>>x>>y;
if(x+y<=t&&(t-x-y)%2==0) continue;
cout<<"No"<<endl;
exit(0);
}
cout<<"Yes"<<endl;
return 0;
} |
#include<iostream>
using namespace std;
int main()
{
long t,x,y,n;
bool flag=true;
cin>>n;
for(long i=1;i<=n;i++)
{
cin>>t>>x>>y;
if((x+y)%2!=t%2||x+y>t) flag=false;
}
if(flag) cout<<"Yes"<<endl; else cout<<"No"<<endl;
return 0;
} |
// C - Traveling
#include <bits/stdc++.h>
using namespace std;
int main(){
int N; cin>>N;
while(N--){
int t,x,y; cin>>t>>x>>y;
if(t<x+y || (t-x-y)&1){ puts("No"); return 0; }
}
puts("Yes");
} |
#include<bits/stdc++.h>
using namespace std;
int n,x,y,t,sum,ans=0;
int main() {
cin>>n;
for(int i=1;i<=n;i++){
cin>>t;
cin>>x>>y;
if(t<x+y)
break;
sum=t-x-y;
if(sum%2==0)
ans++;
}
if(ans==n)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
} |
#include<bits/stdc++.h>
#define reg register
using namespace std;
int n,t,x,y;
int main()
{
scanf("%d",&n);
for(reg int i=1;i<=n;i++)
{
scanf("%d%d%d",&t,&x,&y);
if(x+y>t||!((x+y)&1)&&t&1||(x+y)&1&&!(t&1))return puts("No"),0;
}
puts("Yes");
return 0;
} |
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
int q,w,e;
cin>>q>>w>>e;
int zong=w+e;
if((q-zong)%2==1||zong>q){
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int t[1000001],x[1000001],y[1000001];
int main(){
int n,i,f=0;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d%d%d",&t[i],&x[i],&y[i]);
if((t[i]-x[i]-y[i])%2==1||(t[i]-x[i]-y[i])<0){printf("No\n");f=1;break;}
}
if(f==0)printf("Yes\n");
return 0;
} |
#include<iostream>
#include<iomanip>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<set>
using namespace std;
int t,x,y,n;
int bj=1;
int main() {
cin>>n;
while(n--){
cin>>t>>x>>y;
if(x+y>t)bj=0;
if(((x+y)&1)!=(t&1))bj=0;
}
if(bj)puts("Yes");
else puts("No");
return 0;
} |
#include<iostream>
#include<cstdio>
using namespace std;
int n,t,x,y;
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d%d%d",&t,&x,&y);
if (t<x+y||(t-x-y)%2==1)
{
printf("No\n");
return 0;
}
}
printf("Yes\n");
return 0;
} |
#include<stdio.h>
using namespace std;
int main(){
int n,t,x,y,flag=1;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d %d %d",&t,&x,&y);
// printf("%d\n",t%(x+y)!=0);
if(t%(x+y)!=0 && (t-x-y)%2!=0 || t<(x+y)) flag=0;
}
printf("%s\n",flag?"Yes":"No");
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int n;
int t,x,y;
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
int tt,xx,yy;
cin>>tt>>xx>>yy;
int d=abs(xx-x)+abs(yy-y);
if(tt-t<d||(tt-t)%2!=d%2)
{
cout<< "No";
return 0;
}
}
cout<<"Yes";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N,t,x,y;
cin>>N;
int flag=0;
for(int i=1;i<=N;i++)
{
cin>>t>>x>>y;
int tmp=x+y;
if(tmp>t) flag=1;
else
if((t-tmp)%2==1) flag=1;
}
if(flag==0) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,i,t,x,y,flag=1;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d %d %d",&t,&x,&y);
if(!(t-(x+y)>=0&&(t-(x+y))%2==0))
{
flag=0;
}
}
if(flag)
{
printf("Yes");
}
else
{
printf("No");
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int t[n+10],x[n+10],y[n+10];
for(int i=1;i<=n;i++){
cin>>t[i]>>x[i]>>y[i];
}
for(int i=1;i<=n;i++){
if(x[i]+y[i]>t[i]||(t[i]-x[i]-y[i])%2!=0){
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.