目录
1968: Permutation Descent Counts
1977: Bit-reversal Permutation
2005: Nearest Maintenance Point
1900: 锋芒不露
#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
using namespace std;
int L[105],R[105];
int main()
{
int n;
int a,b;
int Max;
while(scanf("%d",&n)!=EOF)
{
if(n==0) break;
memset(L,0,sizeof(L));
memset(R,0,sizeof(R));
int lm=100,rm=0;
for(int k=1;k<=n;k++)
{
scanf("%d%d",&a,&b);
L[a]++;R[b]++;
if(lm>a) lm=a;
if(rm<b) rm=b;
Max=0;
int i=lm,j=rm;
int p=L[lm],q=R[rm];
int match=0;
while(match!=k)
{
if(p==0) {p=L[++i];continue;}
if(q==0) {q=R[--j];continue;}
if((i+j)>Max) Max=i+j;
if(p==q)
{
match+=p;
i++;j--;
p=L[i];q=R[j];
}else if(p<q)
{
q-=p;
match+=p;
p=L[++i];
}else if(p>q)
{
p-=q;
match+=q;
q=R[--j];
}
}
printf("%d\n",Max);
}
printf("\n");
}
return 0;
}1901: 赏赐 OR 灾难
#include<iostream>
#include<string>
#include<cstdio>
#include<stack>
#include<algorithm>
using namespace std;
const int MAXN=100005;
const int INF=1000000000;
int Min[MAXN];//Min[i]表示前i个宝物中的最小价值
int w[MAXN];
stack<int> s;//单调栈
int main()
{
ios::sync_with_stdio(false);
int n;
while(cin>>n)
{
while(!s.empty()) s.pop();
for(int i=1;i<=n;i++)
{
cin>>w[i];
if(i==1) Min[i]=w[i];
else Min[i]=min(Min[i-1],w[i]);
}
bool flag=false;
s.push(w[n]);
for(int i=n-1;i>=2;i--)
{
int a=Min[i-1];//i左边的最小值
int c=-1;
while(!s.empty()&&s.top()<w[i])
{
c=s.top();
s.pop();
}
s.push(w[i]);
if(c>a)
{
flag=true;
break;
}
}
if(flag) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
}1904: 精灵的交际网
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=50005;
int fa1[maxn],rel[maxn];
int find1(int x)
{
if(fa1[x]==x)
return fa1[x];
int tem=fa1[x];
fa1[x]=find1(fa1[x]);
rel[x]=(rel[x]+rel[tem])%2;
return fa1[x];
}
void merge1(int x,int y)
{
int fx=find1(x),fy=find1(y);
fa1[fx]=fy;
rel[fx]=(rel[y]-rel[x]+1)%2;
}
int main()
{
int T,cnt=0;
scanf("%d",&T);
while(T--)
{
int n,m,flag1=-1,flag2=0;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
fa1[i]=i;
rel[i]=0;
}
for(int i=0;i<m;i++)
{
int a,b;
scanf("%d%d",&a,&b);
if(flag2==1)
continue;
if(find1(a)==find1(b))
{
if(rel[a]==rel[b]&&flag2==0)
{
flag2++;
flag1=i+1;
}
}
else
merge1(a,b);
}
printf("%d\n",flag1);
}
return 0;
}1908: The Big Escape
#include <iostream>
#include<queue>
#include<vector>
#include<algorithm>
#include<functional>
#include<string>
#include<string.h>
#include<cmath>
#include<cstdio>
using namespace std;
const int maxn = 150000+10;
int erear,head[maxn];
int root,n;
int vis[maxn];
int cnt[maxn];
int ans = -1;
int kase = 1;
struct node
{
int x,to,next;
}E[maxn];
void __init__()
{
memset(head,-1,sizeof(head));
erear = 0;
}
void build(int x,int y)
{
E[erear].x = x;
E[erear].to= y;
E[erear].next = head[x];
head[x] = erear++;
}
int dfs(int root,int &sum)
{
for(int i = head[root]; i!=-1 ;i = E[i].next)
{
if(vis[E[i].to]==0)
{
vis[E[i].to] = 1;
sum++;
dfs(E[i].to,sum);
}
}
}
int main()
{
while(~scanf("%d%d",&n,&root))
{
__init__();
ans = 0;
memset(vis,0,sizeof(vis));
memset(cnt,0,sizeof(cnt));
for(int i = 0;i < n-1;i++)
{
int x,y;
scanf("%d%d",&x,&y);
build(x,y);
build(y,x);
}
vis[root] = 1;
for(int i = head[root];i!=-1 ;i=E[i].next)
{
int sum = 1;
vis[E[i].to] = 1;
dfs(E[i].to,sum);
ans = max(sum,ans);
/*if(kase == 10003)
cout<<sum<<endl;*/
}
cout<<"Case #"<<kase++<<":"<<ans<<endl;
}
return 0;
}1909: Perfect Chocolate
#include <cstdio>
#include <cstring>
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
const int MAXN = 1e5 + 5;
const int SIZE = 2e5 + 5;
char S[MAXN];
int main(){
int cas = 1;
while(~scanf("%s", S)){
int len = strlen(S);
int sum = 0;
for(int i = 0;i < len;i ++){
if(S[i] == '1') sum ++;
else sum --;
}
if(sum < 0) sum = -sum;
if(sum > 0) sum --;
printf("Case #%d:%d\n",cas ++, sum);
}
return 0;
}1911: Card Game
#include<iostream>
#include<string>
#include<stdio.h>
#include<string.h>
using namespace std;
typedef long long LL;
const int MAXN=1<<18;
int a[MAXN],b[MAXN];
char tmp[20];
void FWT(int a[],int n)
{
for(int d=1;d<n;d<<=1)
for(int m=d<<1,i=0;i<n;i+=m)
for(int j=0;j<d;j++)
{
int x=a[i+j],y=a[i+j+d];
//xor:a[i+j]=x+y,a[i+j+d]=(x-y+mod)%mod;
//and:a[i+j]=x+y;
a[i+j+d]=x+y;
}
}
void UFWT(int a[],int n)
{
for(int d=1;d<n;d<<=1)
for(int m=d<<1,i=0;i<n;i+=m)
for(int j=0;j<d;j++)
{
int x=a[i+j],y=a[i+j+d];
//xor:a[i+j]=(x+y)/2,a[i+j+d]=(x-y)/2;
//and:a[i+j]=x-y;
a[i+j+d]=y-x;
}
}
int main()
{
int T,cas=0;
scanf("%d",&T);
while(T--)
{
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
int n,m,q;
scanf("%d%d",&n,&m);
int tot=1<<m;
for(int i=0;i<n;i++)
{
scanf("%s",tmp);
int len=strlen(tmp);
int t=0;
for(int j=0;j<len;j++)
{
t<<=1;
t|=(tmp[j]-'0');
}
a[t]++;
}
// for(int i=0;i<=12;i++)
// cout<<a[i]<<" ";
// cout<<endl;
for(int i=0;i<n;i++)
{
scanf("%s",tmp);
int len=strlen(tmp);
int t=0;
for(int j=0;j<len;j++){
t<<=1;
t|=(tmp[j]-'0');
}
b[t]++;
}
// for(int i=0;i<=14;i++)
// cout<<b[i]<<" ";
// cout<<endl;
FWT(a,tot); FWT(b,tot);
for(int i=0;i<tot;++i)
a[i]=a[i]*b[i];
UFWT(a,tot);
scanf("%d",&q);
printf("Case #%d:\n",++cas);
while(q--)
{
int t=0;
scanf("%s",tmp);
int len=strlen(tmp);
for(int i=0;i<len;i++)
{
t<<=1;
t|=(tmp[i]-'0');
}
printf("%d\n",a[t]);
}
}
return 0;
}1912: One Boring Problem
#include <cstdio>
#include <cstring>
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5;
const int SIZE = 2e5 + 5;
const int mod = 1e9 + 7;
LL CC[MAXN];
LL CCD[MAXN];
LL mod_pow(LL x, LL n, LL p){
LL ret = 1;
while(n){
if(n & 1) ret = ret * x % p;
x = x * x % p;
n >>= 1;
}
return ret;
}
void CC_init(){
CC[0] = CC[1] = 1;
CCD[0] = 1;
CCD[1] = 1;
for(int i = 2;i < MAXN;i ++){
CC[i] = CC[i - 1] * i % mod;
CCD[i] = mod_pow(CC[i], mod - 2, mod) % mod;//乘法逆元
}
}
LL C(int m, int n, LL p){
if(m > n) return 0;
if(n - m < m) m = n - m;
LL up = 1, down = 1;
up = CC[n] * CCD[n - m] % p;
down = CCD[m];
return up * down % p;
}
LL lucas(int m, int n, LL p){
if(m == 0) return 1;
return C(m % p, n % p, p) * lucas(m / p, n / p, p) % p;
}
int n, m;
int main(){
CC_init();
while(~scanf("%d%d", &n, &m)){
LL ans = 0, tmp = 0;
if(m == 1){
printf("1\n");
continue;
}
n = n - m;
for(int i = 1;i <= n;i ++){
ans = (ans + lucas(m - 1 - 1, n - i + m - 1 - 1, mod)) % mod;//隔板法或者叫做插板法
//printf("[%d]\n", ans);
tmp = 0;
int flag = 1;
for(int j = 1;j * i + i <= n && j < m;j ++){
tmp = (tmp + lucas(m - 1 - 1, n - i - j * i + m - 1 - 1, mod) * lucas(j, m - 1, mod) * flag % mod + mod) % mod;
flag = - flag;
}
ans = (ans + mod - tmp) % mod;
}
printf("%lld\n", ans);
}
return 0;
}1913: 一条大笨龙送礼物
#include <cstdio>
#include <cstring>
#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
using namespace std;
const int MAXN = 1e5 + 5;
const int SIZE = 2e5 + 5;
int Sum[MAXN * 3], Col[MAXN * 3];
int a[MAXN];
int n, m, k;
struct o {
int l, r;
} O[MAXN];
void push_up(int rt) {
Sum[rt] = Sum[rt << 1] + Sum[rt << 1 | 1];
}
void push_down(int rt, int m) {
if(Col[rt] != -1) {
Col[rt << 1] = Col[rt << 1 | 1] = Col[rt];
Sum[rt << 1] = (m - (m >> 1)) * Col[rt];
Sum[rt << 1 | 1] = (m >> 1) * Col[rt];
Col[rt] = -1;
}
}
void build(int lowv, int l, int r, int rt) {
Col[rt] = -1;
Sum[rt] = 0;
if(l == r) {
Sum[rt] = a[l] > lowv;
return;
}
int mid = (l + r) >> 1;
build(lowv, lson);
build(lowv, rson);
push_up(rt);
}
void update(int L, int R, int v, int l, int r, int rt) {
if(L > R) return;
if(L <= l && r <= R) {
Sum[rt] = (r - l + 1) * v;
Col[rt] = v;
return ;
}
push_down(rt, r - l + 1);
int mid = (l + r) >> 1;
if(L <= mid) update(L, R, v, lson);
if(R > mid) update(L, R, v, rson);
push_up(rt);
}
int query(int L, int R, int l, int r, int rt) {
if(L <= l && r <= R) {
return Sum[rt];
}
int mid = (l + r) >> 1;
push_down(rt, r - l + 1);
int ret = 0;
if(L <= mid) ret += query(L, R, lson);
if(R > mid) ret += query(L, R, rson);
return ret;
}
bool C(int mid, int len) {
build(mid, 1, n, 1);
for(int i = 0; i < len; i ++) {
int s1 = query(O[i].l, O[i].r, 1, n, 1);
int s0 = O[i].r - O[i].l + 1 - s1;
int cz = (s1 & 1) == 1;
int qlk = s1 / 2;
update(O[i].l, O[i].l + qlk - 1 + cz, 1, 1, n, 1);
update(O[i].l + qlk + cz, O[i].r - qlk, 0, 1, n, 1);
update(O[i].r - qlk + 1, O[i].r, 1, 1, n, 1);
}
return query(k, k, 1, n, 1) == 0;
}
int main() {
while(~scanf("%d%d%d", &n, &m, &k)) {
for(int i = 1; i <= n; i ++) {
scanf("%d", &a[i]);
}
int op, len = 0, zl;
for(int i = 1; i <= m; i ++) {
scanf("%d", &op);
if(op == 1) {
scanf("%d%d", &O[len].l, &O[len].r);
len ++;
} else {
scanf("%d", &zl);
len -= zl;
len = len < 0 ? 0 : len;
}
}
//printf("[%d]\n", len);
int lb = 0, ub = SIZE;
while(ub - lb > 1) {
int mid = (ub + lb) >> 1;
if(C(mid, len)) ub = mid;
else lb = mid;
}
printf("%d\n", ub);
}
return 0;
}1914: John and his party
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
#include<sstream>
#include<vector>
#include<cmath>
#define LL long long
#define md int mid = (L+R)>>1
#define ls rt<<1
#define rs rt<<1|1
using namespace std;
const int maxn = 2e5+50000;
int id[maxn<<2],mx[maxn<<2];
int n;
int ans[maxn];
int lazy[maxn<<2];
void push_up(int rt)
{
if(mx[ls]>=mx[rs])
id[rt] = id[ls];
else
id[rt] = id[rs];
mx[rt] = max(mx[ls],mx[rs]);
}
void push_down(int rt)
{
if(lazy[rt])
{
lazy[ls] += lazy[rt];
lazy[rs] += lazy[rt];
mx[ls] += lazy[rt];
mx[rs] += lazy[rt];
lazy[rt] = 0;
}
}
void build(int L,int R,int rt)
{
if(L==R)
{
id[rt] = L;
mx[rt] = -L;
return ;
}
md;
build(L,mid,ls);
build(mid+1,R,rs);
push_up(rt);
}
void update(int l,int r,int L,int R,int rt)
{
// cout<<"diap"<<endl;
if(l<=L&&R<=r)
{
lazy[rt]++;
mx[rt]++;
return ;
}
push_down(rt);
md;
if(l<=mid)
update(l,r,L,mid,ls);
if(r>mid)
update(l,r,mid+1,R,rs);
push_up(rt);
}
void change(int p,int L,int R,int rt)
{
if(L==R)
{
mx[rt] = -0x3f3f3f3f;
// id[rt] = L;
return ;
}
md;
push_down(rt);
if(mid>=p)
change(p,L,mid,ls);
else
change(p,mid+1,R,rs);
push_up(rt);
}
int main()
{
while(~scanf("%d",&n))
{
memset(ans,-1,sizeof(ans));
build(1,n,1);
memset(lazy,0,sizeof(lazy));
for(int i = 0 ;i < n;i++)
{
int op,x;
scanf("%d%d",&op,&x);
if(!op)
{
//cout<<"fuck"<<endl;
update(1,x,1,n,1);
//cout<<"gan"<<endl;
}
else
update(x,n,1,n,1);
if(mx[1]<0)
continue;
while(!mx[1])
{
ans[id[1]] = i+1;
change(id[1],1,n,1);
}
}
for(int i = 1;i <= n;i++ )
printf("%d%c",ans[i],i==n?'\n':' ');
}
return 0;
}1915: John and his farm
#include <queue>
#include <stack>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <string>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef long double LB;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
void debug() { cout << endl; }
template<typename T, typename ...R> void debug (T f, R ...r) { cout << "[" << f << "]"; debug (r...); }
const int MAXN = 1e5 + 5;
const int MAXM = 20;
int n, m;
struct Edge {
int v, next;
} edge[MAXN << 1];
int head[MAXN], tot;
int dep[MAXN], siz[MAXN], fa[MAXN][MAXM];
LL all[MAXN], sum[MAXN];
int root;
void init_edge() {
tot = 0;
memset(head, -1, sizeof(head));
}
inline void add_edge(int u, int v) {
edge[tot] = Edge {v, head[u]};
head[u] = tot ++;
}
void dfs(int u, int pre, int d) {
int v;
siz[u] = 1;
dep[u] = d;
sum[u] = 0;
fa[u][0] = pre;
for(int i = head[u]; ~i; i = edge[i].next) {
v = edge[i].v;
if(v == pre) continue;
dfs(v, u, d + 1);
siz[u] += siz[v];
sum[u] += sum[v];
sum[u] += siz[v];
}
}
void dfs2(int u, int pre) {
int v;
for(int i = head[u]; ~i; i = edge[i].next) {
v = edge[i].v;
if(v == pre) continue;
all[v] = all[u] + (n - 1 - siz[v]) - (siz[v] - 1);
dfs2(v, u);
}
}
void lca_init() {
for(int j = 1; j < MAXM; ++j) {
for(int i = 1; i <= n; ++i) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
}
}
int lca(int u, int v) {
while(dep[u] != dep[v]) {
if(dep[u] < dep[v]) swap(u, v);
int d = dep[u] - dep[v];
for(int i = 0; i < MAXM; i++) {
if(d >> i & 1) u = fa[u][i];
}
}
if(u == v) return u;
for(int i = MAXM - 1; i >= 0; i--) {
if(fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
}
return fa[u][0];
}
int son(int u, int v) {
while(dep[v] > dep[u] + 1) {
int w = v;
for(int j = 0; j < MAXM; ++j) {
if(dep[fa[v][j]] < dep[u] + 1) break;
w = fa[v][j];
}
v = w;
}
return v;
}
int main() {
int u, v, w;
while(~scanf("%d %d", &n, &m)) {
init_edge();
for(int i = 1; i <= n - 1; ++i) {
scanf("%d %d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
dfs(root = 1, 0, 0);
all[root] = sum[root];
dfs2(root, 0);
lca_init();
while(m --) {
scanf("%d %d", &u, &v);
if(dep[u] > dep[v]) swap(u, v);
w = lca(u, v);
int dist, sizu, sizv;
LL sumu, sumv;
double ans;
if(w != u) {
/** 有lca **/
dist = dep[u] + dep[v] - 2 * dep[w];
sizu = siz[u];
sumu = sum[u];
sizv = siz[v];
sumv = sum[v];
} else {
/**一条链**/
dist = dep[v] - dep[u];
w = son(u, v);
sizu = n - siz[w];
sumu = all[u] - sum[w] - siz[w];
sizv = siz[v];
sumv = sum[v];
}
ans = 1.0 + dist + 1.0 * ((LL)sizu * sumv + (LL)sizv * sumu) / ((LL)sizu * sizv);
printf("%.8f\n", ans);
}
}
return 0;
}1917: There is no SSR
#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
const int maxn=105;
struct Matrix{
int n;
double m[maxn][maxn];
void init(int sz){
n=sz;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
m[i][j]=0;
}
Matrix(int sz){init(sz);}
void set_I(){
for(int i=0;i<n;i++) m[i][i]=1.0;
}
Matrix operator* (const Matrix& a){
Matrix ans(n);
for(int k=0;k<n;k++)
for(int i=0;i<n;i++)
for(int j=0;j<n;j++){
ans.m[i][j]+=m[i][k]*a.m[k][j];
}
return ans;
}
};
int main(){
double p,q;
int n,m;
while(scanf("%lf%lf%d%d",&p,&q,&n,&m)!=EOF){
Matrix base(n),ans(n);
for(int i=0;i<n;i++) base.m[i][0]=p*pow(q,i);
for(int i=0;i<n-1;i++) base.m[i][i+1]=1.0;
ans.m[0][0]=1-pow(q,n);
for(int i=1;i<n;i++) ans.m[0][i]=1;
m=m-n;
while(m){
if(m&1) ans=ans*base;
m>>=1;
base=base*base;
}
printf("%.6lf\n",1-ans.m[0][0]);
}
}1919: 不醉不归
#include<iostream>
#include<string.h>
using namespace std;
int dp0[500][500],dp1[500][500],s[500][500];
bool mp[500][500];
int main()
{
int N,M,K;
while (~scanf("%d%d%d",&N,&M,&K)&&N&&M&&K)
{
int ans=0;
memset(mp,0,sizeof(mp));
memset(dp0,-1,sizeof(dp0));
memset(dp1,-1,sizeof(dp1));
for(int i=1;i<=N;i++)
for(int j=1;j<=M;j++)
{
scanf("%d",&s[i][j]);
s[i][j]+=s[i][j-1];
}
int n; scanf("%d",&n);
while (n--)
{
int x,y;
scanf("%d%d",&x,&y);
mp[x][y]=1;
}
dp0[0][0]=0;
for(int i=1;i<=N;i++)
{
dp0[i][0]=dp0[i-1][0];
for(int j=1;j<=K&&j<=i*M;j++)
{
dp0[i][j]=dp0[i-1][j];
dp1[i][j]=max(dp0[i][j-1],dp1[i-1][j]);
for(int k=1,p=1;k<=j&&p<=M;k++) //k表示在第i个架子花k元钱，p表示目前已经取到第p个瓶子
for(;p<=M;p++)
if (mp[i][p]) //当第i个架子的第p个是再来一瓶的瓶子的时候，取完之后有奖码，p可以继续循环而价格不多花钱
{
if (dp0[i-1][j-k]>=0) dp1[i][j]=max(dp1[i][j],dp0[i-1][j-k]+s[i][p]);
//在前i-1个架子中花j-k元，而在第i个架子上花k元刚好取到第p个瓶子，且那个再来一瓶放在之后取
if (dp1[i-1][j-k+1]>=0) dp1[i][j]=max(dp1[i][j],dp1[i-1][j-k+1]+s[i][p]);
//在前i-1个架子花j-k+1元且之前没有拿的奖码放在第i个架子上用，所以用j-k+1元就可取p个瓶子
if (dp0[i-1][j-k+1]>=0) dp0[i][j]=max(dp0[i][j],dp0[i-1][j-k+1]+s[i][p]); //由于当前遇到了一个再来一瓶，所以我们可以把这个奖码用在前i-1行，相当于在前i-1行可以多1元钱
} else //当第i个架子第p个不是再来一瓶的时候
{
if (dp0[i-1][j-k]>=0) dp0[i][j]=max(dp0[i][j],dp0[i-1][j-k]+s[i][p]);
//直接从之前的继承
if (dp1[i-1][j-k+1]>=0) dp0[i][j]=max(dp0[i][j],dp1[i-1][j-k+1]+s[i][p]); //把之前的奖码用掉
p++; break; //没有再来一瓶，所以处理完毕后就要跳出，得多花钱
}
}
if (i==N) ans=max(ans,max(dp0[i][K],dp1[i][K]));
}
printf("%d\n",ans);
}
return 0;
}1922: Irony Ring
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<stack>
using namespace std;
#define LL long long
const int maxn=100010;
struct node
{
LL r,R,h;
bool operator<(const node &res)const
{
if(R==res.R) return r>res.r;
else return R>res.R;
}
}a[maxn];
stack<node> s;
int main()
{
int n;
while(~scanf("%d",&n))
{
while(!s.empty()) s.pop();
for(int i=0;i<n;i++) scanf("%lld%lld%lld",&a[i].r,&a[i].R,&a[i].h);
sort(a,a+n);
LL MAX=0,ans=0;
for(int i=0;i<n;i++)
{
while(!s.empty()&&s.top().r>=a[i].R)
{
ans-=s.top().h;
s.pop();
}
ans+=a[i].h;
s.push(a[i]);
MAX=max(MAX,ans);
}
printf("%lld\n",MAX);
}
return 0;
} 1923: Mysterious Block D
#include <queue>
#include <stack>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <string>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef long double LB;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
void debug() { cout << endl; }
template<typename T, typename ...R> void debug (T f, R ...r) { cout << "[" << f << "]"; debug (r...); }
const int MAXN = 111 + 2;
const int HASH_MAX = 1000007;
const int HASH_SIZ = 1e5 + 5;
const int BASE = 131;
struct HashMap {
struct Edge {
ULL d[4];
int next;
Edge() {}
Edge(ULL dx[], int nxt) : next(nxt) { for(int i = 0; i < 4; ++i) d[i] = dx[i]; }
} edge[HASH_SIZ];
int head[HASH_MAX], tot;
void hash_init() {
tot = 0;
memset(head, -1, sizeof(head));
}
bool hash_query(ULL dx[4]) {
sort(dx, dx + 4);
ULL x = (dx[0] & dx[1] & dx[2] & dx[3]);
ULL u = x % HASH_MAX;
for(int i = head[u]; ~i; i = edge[i].next) {
bool equ = true;
for(int j = 0; j < 4; ++j) {
if(dx[j] != edge[i].d[j]) { equ = false; break; }
}
if(equ) return true;
}
return false;
}
ULL hash_add(ULL dx[4]) {
sort(dx, dx + 4);
ULL x = (dx[0] & dx[1] & dx[2] & dx[3]);
ULL u = x % HASH_MAX;
for(int i = head[u]; ~i; i = edge[i].next) {
bool equ = true;
for(int j = 0; j < 4; ++j) {
if(dx[j] != edge[i].d[j]) { equ = false; break; }
}
if(equ) return x;
}
edge[tot] = Edge(dx, head[u]);
head[u] = tot ++;
return x;
}
} hash_xxw;
int n, m;
char maze[MAXN][MAXN];
bool vis[MAXN][MAXN];
void dfs(int x, int y, int& xx, int& yy) {
if(x >= n || y >= m) return;
if(vis[x][y] || maze[x][y] == '#') return;
vis[x][y] = true;
xx = max(x, xx), yy = max(y, yy);
dfs(x + 1, y, xx, yy);
dfs(x, y + 1, xx, yy);
}
ULL up(int sx, int sy, int tx, int ty) {
ULL ret = 0;
for(int i = sx; i <= tx; ++i) {
for(int j = sy; j <= ty; ++j) {
ret = ret * BASE + (maze[i][j] == '+');
}
}
return ret;
}
ULL right(int sx, int sy, int tx, int ty) {
ULL ret = 0;
for(int j = sy; j <= ty; ++j) {
for(int i = tx; i >= sx; --i) {
ret = ret * BASE + (maze[i][j] == '+');
}
}
return ret;
}
ULL down(int sx, int sy, int tx, int ty) {
ULL ret = 0;
for(int i = tx; i >= sx; --i) {
for(int j = ty; j >= sy; --j) {
ret = ret * BASE + (maze[i][j] == '+');
}
}
return ret;
}
ULL left(int sx, int sy, int tx, int ty) {
ULL ret = 0;
for(int j = ty; j >= sy; --j) {
for(int i = sx; i <= tx; ++i) {
ret = ret * BASE + (maze[i][j] == '+');
}
}
return ret;
}
int main() {
#ifdef ___LOCAL_WONZY___
freopen ("input.txt", "r", stdin);
#endif // ___LOCAL_WONZY___
while(~scanf("%d %d", &n, &m)) {
memset(vis, false, sizeof(vis));
for(int i = 0; i < n; ++i) {
scanf("%s", maze[i]);
}
int xx, yy;
ULL dx[4];
hash_xxw.hash_init();
for(int i = 0; i < n; ++i) {
for(int j = 0; j < m; ++j) {
if(maze[i][j] == '#' || vis[i][j]) continue;
xx = i, yy = j;
dfs(i, j, xx, yy);
dx[0] = up(i, j, xx, yy);
dx[1] = right(i, j, xx, yy);
dx[2] = down(i, j, xx, yy);
dx[3] = left(i, j, xx, yy);
hash_xxw.hash_add(dx);
}
}
printf("%d\n", hash_xxw.tot);
}
#ifdef ___LOCAL_WONZY___
cout << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;
#endif // ___LOCAL_WONZY___
return 0;
}1924: 那些年寮里的崽儿们
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
int main()
{
int n;
int u=1;
while(scanf("%d",&n)!=EOF)
{
map<string,int> p;
string a[100];
string t;
int index=0;
for(int i=0;i<n;i++)
{
cin>>t;
if(p[t])
{
p[t]++;
}else{
a[index++]=t;
p[t]++;
}
}
printf("Case %d:\n",u++);
for(int i=0;i<index;i++)
{
cout<<a[i]<<" "<<p[a[i]]<<endl;
}
}
return 0;
}1942: Sort String
#include <queue>
#include <string>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ull, ull> puu;
#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-8)
#define fi first
#define se second
//--------------------------
const ll mod = 1000000007;
const int maxn = 100010;
char str[maxn];
int n;
int q;
struct Node {
int left, right;
int num[26];
int lazy;
} node[maxn << 2];
void push_up(int n) {
for(int i = 0; i < 26; i++) {
node[n].num[i] = node[n << 1].num[i] + node[n << 1 | 1].num[i];
}
}
void push_down(int n) {
if(node[n].lazy != -1) {
node[n << 1].lazy = node[n << 1 | 1].lazy = node[n].lazy;
memset(node[n << 1].num, 0, sizeof(node[n << 1].num));
memset(node[n << 1 | 1].num, 0, sizeof(node[n << 1 | 1].num));
node[n << 1].num[node[n].lazy] = (node[n].right - node[n].left + 1) - (node[n].right - node[n].left + 1) / 2;
node[n << 1 | 1].num[node[n].lazy] = (node[n].right - node[n].left + 1) / 2;
node[n].lazy = -1;
}
}
void update(int n, int left, int right, char val) {
if(node[n].left >= left && node[n].right <= right) {
node[n].lazy = val - 'a';
memset(node[n].num, 0, sizeof(node[n].num));
node[n].num[node[n].lazy] = node[n].right - node[n].left + 1;
return ;
}
push_down(n);
int mid = (node[n].left + node[n].right) >> 1;
if(mid >= left)update(n << 1, left, right, val);
if(mid < right)update(n << 1 | 1, left, right, val);
push_up(n);
}
int query(int n, int left, int right, char val) {
if(node[n].left >= left && node[n].right <= right) {
return node[n].num[val - 'a'];
}
push_down(n);
int mid = (node[n].left + node[n].right) >> 1;
int sum = 0;
if(mid >= left)sum += query(n << 1, left, right, val);
if(mid < right)sum += query(n << 1 | 1, left, right, val);
return sum;
}
void build(int n, int left, int right) {
node[n].left = left;
node[n].right = right;
node[n].lazy = -1;
if(left == right) {
node[n].num[str[left] - 'a'] = 1;
return ;
}
int mid = (left + right) >> 1;
build(n << 1, left, mid);
build(n << 1 | 1, mid + 1, right);
push_up(n);
}
void print(int n) {
if(node[n].left == node[n].right) {
for(int i = 0; i < 26; i++) {
if(node[n].num[i] != 0) {
printf("%c", i + 'a');
break;
}
}
return ;
}
push_down(n);
print(n << 1);
print(n << 1 | 1);
}
void solve() {
while(~scanf("%d%d", &n, &q)) {
memset(node, 0, sizeof(node));
scanf("%s", str + 1);
build(1, 1, n);
while(q--) {
int l, r, op;
scanf("%d%d%d", &l, &r, &op);
int num[26] = {0};
for(int i = 0; i < 26; i++) {
num[i] = query(1, l, r, i + 'a');
}
if(op == 1) {
for(int i = 0; i < 26; i++) {
if(num[i] > 0) {
update(1, l, l + num[i] - 1, i + 'a');
l += num[i];
}
}
} else {
for(int i = 25; i >= 0; i--) {
if(num[i] > 0) {
update(1, l, l + num[i] - 1, i + 'a');
l += num[i];
}
}
}
}
print(1);
puts("");
}
}
int main() {
#ifndef ONLINE_JUDGE
freopen("1.in", "r", stdin);
freopen("1.out", "w", stdout);
#endif
solve();
return 0;
}1947: 突然的灵光
#include<cstdio>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<cstring>
#include<vector>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+100;
LL x[maxn];
LL y[maxn];
LL n;
LL slovey()
{
LL yy = y[n/2];
LL sum = 0;
for(int i = 0 ;i<n;i++)
{
sum+=abs(yy-y[i]);
}
return sum;
}
LL slovex()
{
LL xx = x[n/2];
LL tmp = x[n/2]-1;
LL sum = 0;
for(int i = n/2-1;i>=0;i--)
{
sum += abs(x[i]-tmp);
tmp--;
}
tmp = x[n/2]+1;
for(int i = n/2+1;i<n;i++)
{
sum+=abs(x[i]-tmp);
tmp++;
}
return sum;
}
int main()
{
while(~scanf("%lld",&n))
{
for(int i = 0 ;i<n;i++)
{
scanf("%lld%lld",&x[i],&y[i]);
}
sort(x,x+n);
sort(y,y+n);
LL sum = 0;
sum+=slovex();
sum+=slovey();
cout<<sum<<endl;
}
}1949: 小明的烦恼
#include<iostream>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=1e5+10;
const int maxm=1e7+10;
struct node
{
int ls,rs,sum;
int l,r;
}q[maxm];
int a[maxn],father[maxn],root[maxn],s[maxn];
int n,m;
int k;
int build(int l,int r,int d)//建树
{
k++;
int t=k;
q[t].l=l,q[t].r=r;
if(r<d||l>d)
{
q[t].ls=0,q[t].rs=0,q[t].sum=0;
return t;
}
else
{
q[t].sum=1;
if(l==r)
{
q[t].ls=0,q[t].rs=0;
return t;
}
int mid=(l+r)>>1;
q[t].ls=build(l,mid,d);
q[t].rs=build(mid+1,r,d);
return t;
}
}
int find(int x)
{
return x==father[x]?x:father[x]=find(father[x]);
}
int get(int roots,int ss)//找第k大的数
{
if(q[roots].l==q[roots].r)
return q[roots].l;
int ls=q[roots].ls,rs=q[roots].rs;
if(q[ls].sum<ss)
return get(rs,ss-q[ls].sum);
else
return get(ls,ss);
}
int merge(int x,int y)//合并
{
if(q[x].ls==0)
q[x].ls=q[y].ls;
else
{
if(q[y].ls>0)
{
q[x].ls=merge(q[x].ls,q[y].ls);
}
}
if(q[x].rs==0)
q[x].rs=q[y].rs;
else
{
if(q[y].rs>0)
{
q[x].rs=merge(q[x].rs,q[y].rs);
}
}
q[x].sum+=q[y].sum;
return x;
}
int main()
{
while(scanf("%d %d",&n,&m)!=EOF)
{
int maxl=inf,maxr=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
maxl=min(maxl,a[i]);
maxr=max(maxr,a[i]);
}
k=0;
for(int i=1;i<=n;i++)
{
father[i]=i;
s[i]=1;
root[i]=build(maxl,maxr,a[i]);
}
while(m--)
{
int x,y;
int cnd;
scanf("%d",&cnd);
if(cnd==2)
{
scanf("%d %d",&x,&y);
int fx=find(x),fy=find(y);
s[fx]+=s[fy];
father[fy]=fx;
root[fx]=merge(root[fx],root[fy]);
}
else
{
scanf("%d",&x);
int fx=find(x);
printf("%d\n",get(root[fx],(s[fx]+1)>>1));
}
}
}
return 0;
}1952: 地下情报员
#include<cstdio>
#include<iostream>
#include<sstream>
#include<algorithm>
#include<cstring>
#include<vector>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+100;
char s[maxn];
int n,m;
vector<char>G[maxn];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{scanf("%d%d",&n,&m);
scanf("%s",s);
//cout<<s<<endl;
for(int i = 0;i<n;i++)
{
G[i].clear();
}
for(int i = 0;i<n*m;i++)
{
G[i%n].push_back(s[i]);
}
for(int i = 0;i<n;i++)
{
sort(G[i].begin(),G[i].end());
}//cout<<s<<endl;
int sum = 0;
for(int i = 0;i<n*m;i++)
{
int len = G[i%n].size();
sum+=abs(G[i%n][len/2]-s[i]);
}
cout<<sum<<endl;
}
}1954: 吃面包
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<map>
#include<vector>
#include<sstream>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+10;
long long all,pay1,pay2,cost1,cost2;
int main()
{
while(~scanf("%lld%lld%lld%lld%lld",&all,&pay1,&pay2,&cost1,&cost2))
{
if(cost1>cost2)
swap(cost1,cost2),swap(pay1,pay2);
LL ans = -1;
if((all/cost2)<maxn)
{
LL num = all/cost2;
for(int i = 0 ;i<=num;i++)
{
LL pre = all - i*cost2;
ans = max(i*pay2+(pre/cost1)*pay1,ans);
}
cout<<ans<<endl;
}
else
{
LL ans2 = -1;
for(int i = 0;i <= cost2;i++)
{
LL pre = all - i*cost1;
ans2 = max(i*pay1+(pre/cost2)*pay2,ans2);
}for(int i = 0;i <= cost1;i++)
{
LL pre = all - i*cost2;
ans2 = max(i*pay2+(pre/cost1)*pay1,ans2);
}
cout<<ans2<<endl;
}
}
}1956: 数字和
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<map>
#include<vector>
#include<iostream>
#include<cstdio>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+10;
int a[maxn];
int sum[maxn];
int p1,p2,p3;
int n;
int slove()
{
p1 = 2;
p2 = 4;
p3 = 6;
for(;p1<=n;p1++)
{
p2 = max(p2,p1+2);
while(p2<=n&&sum[p1-1]>sum[p2-1]-sum[p1]) p2++;
if(p2>=n||sum[p1-1]<sum[p2-1]-sum[p1])
continue;
p3 = max(p3,p2+2);
while(p3<=n&&sum[p1-1]>sum[p3-1]-sum[p2]) p3++;
if(p3>=n||sum[p3-1]-sum[p2]>sum[p1-1])
continue;
if(sum[n]-sum[p3]==sum[p1-1])
{
cout<<p1<<' '<<p2<<' '<<p3<<endl;
return 41;
}
}
return 0;
}
int main()
{
while(~scanf("%d",&n))
{
for(int i = 1 ;i<=n;i++)
{
scanf("%d",&a[i]);
sum[i] = sum[i-1] + a[i];
}
if(!slove())
{
puts("-1");
}
}
}1957: Apache还想再活五百年
#include<iostream>
#include<string>
#include<map>
#include<set>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<vector>
#include<cstring>
#include<iomanip>
#include<sstream>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=1e5;
int y,y2,m,m2,d,d2;
int month[2][13]={{0,31,28,31,30,31,30,31,31,30,31,30,31},
{0,31,29,31,30,31,30,31,31,30,31,30,31}};
int op(int y)
{
return (y%100!=0&&y%4==0)||(y%400==0);
}
int cal(int y,int m,int d)
{
int sum=0;
sum+=y*365;
for(int i=0;i<y;i++)
{
if(op(i)) sum+=1;
}
if(op(y))
{
for(int i=1;i<m;i++) sum+=month[1][i];
}else
{
for(int i=1;i<m;i++) sum+=month[0][i];
}
sum+=d;
return sum;
}
int main()
{
string s;
int t;
char ch;
while(cin>>y)
{
cin>>ch;cin>>m;cin>>ch;cin>>d;
cin>>y2;cin>>ch;cin>>m2;cin>>ch;cin>>d2;
//cout<<y<<m<<d<<endl;
//cout<<y2<<m2<<d2<<endl;
cout<<abs(cal(y,m,d)-cal(y2,m2,d2))<<endl;
}
return 0;
}1958: 数字游戏
#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
//返回输入值的位数大小
int f(int x)
{
int num=0,i=1;
while(x/i)
{
num++;
i*=10;
}
return num;
}
int main()
{
int t,x,y;
cin>>t;
while(t--)
{
cin>>x>>y;
if(f(x)<f(y)) cout<<"-1"<<endl; //若x的位数比y的小，直接输出“-1”
else
{
int ans=0,i=f(y),x1,y1;
for(int j=1; j<i; j++) //从y最低位开始到次高位停止，记录变换次数
{
x1=x%10;
y1=y%10;
ans+=abs(y1-x1)<(10-abs(y1-x1))?abs(y1-x1):(10-abs(y1-x1));
x/=10;
y/=10;
}
if(x/10) //若x位数大于y，则y最高位变换不需考虑前导零的限制条件
{
do //直接x将多出来的高位变为零并记录次数
{
x1=x%10;
y1=y%10;
ans+=abs(y1-x1)<(10-abs(y1-x1))?abs(y1-x1):(10-abs(y1-x1));
x/=10;
y/=10;
}
while(x);
}
else //若x位数等于y,则y最高位变换次数即最高位之差的绝对值
{
x1=x%10;
y1=y%10;
ans=ans+abs(y1-x1);
}
cout<<ans<<endl;
}
}
return 0;
}1960: 单源最大权路径
#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<fstream>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=100005;
int dist[MAXN];
bool vis[MAXN];
int n;
struct Edge
{
int v;
int cost;
Edge(int _v=0,int _cost=0):v(_v),cost(_cost){}
};
vector<Edge> E[MAXN];
void dfs(int start)//点的编号从1开始
{
vis[start]=true;
for(int i=0;i<E[start].size();i++)
{
int v=E[start][i].v;
int cost=E[start][i].cost;
if(vis[v]) continue;
dist[v]=dist[start]+cost;
dfs(v);
}
}
int main()
{
int T;
cin>>T;
int cas=1;
while(T--)
{
memset(vis,false,sizeof(vis));
for(int i=1;i<=n;i++) dist[i]=-INF;
int e;
cin>>n;
int s;
cin>>s;
e=n-1;
for(int i=1;i<=n;i++) E[i].clear();
//for(int i=1;i<=MAXN;i++) dist[i]=INF;
int u,v,c;
for(int i=0;i<e;i++)
{
int u,v,c;
cin>>u>>v>>c;
E[u].push_back(Edge(v,c));
E[v].push_back(Edge(u,c));
}
dist[s]=0;
dfs(s);
int ans=-INF;
for(int i=1;i<=n;i++)
{
ans=max(dist[i],ans);
}
cout<<"Case #"<<cas++<<": "<<ans<<endl;
}
return 0;
}1963: Feed the rabbit
#include <iostream>
#include <queue>
#include <algorithm>
#include <cstring>
#include <string>
#define LL long long
#define ULL unsigned long long
#define mem(a,n) memset(a,n,sizeof(a))
#define fread freopen("in.txt","r",stdin)
#define fwrite freopen("out.txt","w",stdout)
#define N 100100
#define INF 0x3f3f3f3f
#define eps 1e-9
using namespace std;
LL dis[N],sum[N],dp[110][N],ti[N],que[N];
inline LL dy(int id,int j,int k){
return dp[id-1][j]+sum[j]-dp[id-1][k]-sum[k];
}
inline LL dx(LL x,LL y){
return x-y;
}
int main()
{
ios::sync_with_stdio(false);
int n,m,p,hole,tim;
while(cin>>n>>m>>p){
dis[1]=0;
for(int i=2;i<=n;++i){
cin>>dis[i];
dis[i]+=dis[i-1];
}
for(int i=1;i<=m;++i){
cin>>hole>>tim;
ti[i]=tim-dis[hole];
}
sort(ti+1,ti+m+1);
for(int i=1;i<=m;++i){
sum[i]=sum[i-1]+ti[i];
}
for(int i=1;i<=m;++i){
dp[1][i]=ti[i]*i-sum[i];
}
for(int i=2;i<=p;++i){
int frt=0,tail=-1;
for(int j=1;j<=m;++j){
while(frt<tail&&dy(i,que[frt+1],que[frt])<
ti[j]*dx(que[frt+1],que[frt])){
++frt;
}
while(frt<tail&&dy(i,que[tail],que[tail-1])*dx(j,que[tail])>=
dy(i,j,que[tail])*dx(que[tail],que[tail-1])){
--tail;
}
que[++tail]=j;
int v=que[frt];
//cout<<dp[i-1][v]<<' '<<sum[v]<<' '<<ti[j]<<' '<<v<<endl;
dp[i][j]=dp[i-1][v]+sum[v]-ti[j]*v+ti[j]*j-sum[j];
//printf("i_%d j_%d %lld\n",i,j,dp[i][j]);
}
}
//for(int i=1;i<=p;i++)
//for(int j=0;j<=m;j++) printf("i_%d j_%d %lld\n",i,j,dp[i][j]);
cout<<dp[p][m]<<endl;
}
return 0;
}1964: Problem_hc
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<vector>
#define N (1<<16)
using namespace std;
long long dp[N][16];
int num[N],n;
bool mp[16][16];
vector<int> st[20];
int main()
{
int T_T,T;
cin>>T_T;T=T_T;
for(int i=1;i<(1<<16);i++) //首先预处理出所有状态及对应参加人数
{
int status=i,cnt=0;
while(status)
{
if (status&1) cnt++;
status>>=1;
}
num[i]=cnt;
st[cnt].push_back(i);
}
while(T_T--)
{
char ch[20];
scanf("%d",&n);
int fs=(1<<n)-1;
for(int i=0;i<n;i++)
{
scanf("%s",ch);
for(int j=0;j<n;j++)
mp[i][j]=ch[j]-48;
}
memset(dp,0,sizeof(dp));
for(int i=0;i<n;i++) dp[1<<i][i]=1;
for(int i=1;i<n;i<<=1) //人数几何增长
{
int sz=st[i].size();
for(int j=0;j<sz&&st[i][j]<=fs;j++) //枚举参与人数为i的状态
{
int st1=st[i][j],x=fs^st1;
if ((st1&3)==3) continue; //如果1和2在同一个半区则不行
for(int k=0;k<n;k++) //枚举状态st1的获胜者k
{
if (!((1<<k)&st1)) continue; //k当然要参加
for(int st2=x;st2;st2=(st2-1)&x) //枚举x的所有自己，找合法的st2
{
if (num[st2]!=i||(st2&3)==3) continue; //如果参与人数也为i而且1、2不在一个半区，那么合法
for(int l=0;l<n;l++) //枚举st2的获胜者l
{
if (!((1<<l)&st2)) continue; //l当然要参加
if (mp[k][l]) dp[st1|st2][k]+=dp[st1][k]*dp[st2][l]; //谁获胜方案数就加给谁
else dp[st1|st2][l]+=dp[st1][k]*dp[st2][l];
}
}
}
}
}
printf("Case #%d: %lld\n",T-T_T,dp[fs][n-1]);
}
return 0;
}1965: Message
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string>
#include <stack>
#include <queue>
#include <set>
#include <map>
using namespace std;
#define move(a)(1<<(a))
typedef long long ll;
typedef pair<int,int>PA;
const int N = 100900;
const int M = 60;
const int INF = 0x3fffffff;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int mod = 1001113;
int dp[1<<15][M],dis[M][M];
int st[12]; //存储boss想要哪些员工知道的编号
//斯坦纳树:在平面中给你n个点，问你其中m个点到点p的最小生成树，一般n<=10
//dp[M个必须知道消息的人组成的状态][到老板或某个员工]:最小花费
//将老板看做0点，最后的答案就是dp[(1<<m)-1][0]
//dp[i][j]的松弛:
//dp[i][j] = min{dp[i][j],dp[k][i]+dp[l][i]},其中k和l是对j的一个划分
//dp[i][j] = min{dp[i][j],dp[i][j']+dist[j'][j]},j与j'有边相连
void cal( int n , int m )
{
//初始化
for( int sta = 0 ; sta < move(n) ; ++sta ){
for( int i = 0 ; i <= n+m ; ++i )
dp[sta][i] = INF;
}
for( int i = 0 ; i < n ; ++i ){
for( int j = 0 ; j <= n+m ; ++j )
//n个人中的第i个人到第j号人的花费就是st[i]到j间的最小花费
dp[move(i)][j] = dis[st[i]][j];
}
//状态松弛
for( int sta = 1 ; sta < move(n) ; ++sta ){
//是否有子集
if( sta&(sta-1) ){
for( int i = 0 ; i <= n+m ; ++i ){
for( int j = sta ; j > 0 ; j = (j-1)&sta ){
if( dp[sta][i] > dp[sta^j][i]+dp[j][i] )
dp[sta][i] = dp[sta^j][i]+dp[j][i];
}
}
for( int i = 0 ; i <= n+m ; ++i ){
for( int j = 0 ; j <= n+m ; ++j )
if( dp[sta][i] > dp[sta][j]+dis[j][i] )
dp[sta][i] = dp[sta][j]+dis[j][i];
}
}
}
}
void floyed( int n )
{
for( int k = 0 ; k <= n ; ++k ){
for( int i = 0 ; i <= n ; ++i ){
for( int j = 0 ; j <= n ; ++j ){
dis[i][j] = min( dis[i][j] , dis[i][k]+dis[k][j] );
}
}
}
}
int main()
{
// freopen("1.in","r",stdin);
// freopen("yuan.out","w",stdout);
int T;
scanf("%d",&T);
while( T-- ){
memset( dis , -1 , sizeof(dis) );
int n,m;
scanf("%d%d",&n,&m);
for( int i = 1 ; i <= n ; ++i ){
for( int j = 1 ; j <= n ; ++j ){
scanf("%d",&dis[i][j]);
}
}
int a,b;
for( int i = 0 ; i < m ; ++i ){
scanf("%d%d",&a,&b);
dis[0][a] = dis[a][0] = b;
//标记老板想要哪些员工知道消息，老板与这些员工间的连边为花费
st[i] = a;
}
for( int i = 1 ; i <= n ; ++i ){
if( dis[0][i] == -1 ){
//对于某些不一定要知道消息的员工，老板与他们间的连边为无穷
dis[0][i] = dis[i][0] = INF;
}
}
dis[0][0] = 0;
floyed(n);
cal(m,n-m);
printf("%d\n",dp[move(m)-1][0]);
}
return 0;
}1968: Permutation Descent Counts
# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <bitset>
# include <set>
# include <cmath>
# include <algorithm>
using namespace std;
#define lowbit(x) ((x)&(-x))
#define pi acos(-1.0)
#define eps 1e-8
#define MOD 1001113
#define INF 0x3f3f3f3f
#define LL long long
inline int scan() {
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;
}
inline void Out(int a) {
if(a<0) {putchar('-'); a=-a;}
if(a>=10) Out(a/10);
putchar(a%10+'0');
}
#define MX 105
//Code begin...
int dp[MX][MX];
void Init()
{
dp[1][0]=1;
for (int i=2;i<=100;i++)
{
for (int j=0;j<=i-1;j++)
{
dp[i][j] = dp[i-1][j]*(j+1)%MOD;
if (j!=0)
dp[i][j] = (dp[i][j]+dp[i-1][j-1]*(i-j))%MOD;
}
}
}
int main()
{
Init();
int t = scan();
while (t--)
{
int c = scan();
int n = scan();
int m = scan();
printf("%d %d\n",c,dp[n][m]);
}
return 0;
}1969: TFSudoku
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stack>
#include <math.h>
#include <algorithm>
#include <map>
#include <string>
#define INF 0x3f3f3f3f
#define MS(x,y) memset(x, y, sizeof(x))
#define MOD 1000000007
#define LL long long int
using namespace std;
struct node
{
int x,y;
}z[10][10];
int f[10][10][2][10];//前2维表示第几行第几列。第3维表示格子的上下。第4维表示那些数字不能填，0记录剩余可填的数字数
bool xie[10][10];//记录有斜杠的格子
int T;
char s[5];
void show()
{
//printf("*****************************\n");
for(int i=0;i<6;++i)
{
for(int j=0;j<6;++j)
{
if(xie[i][j])
{
printf("%d/%d ", z[i][j].x, z[i][j].y);
}
else
printf("%d ", z[i][j].x);
}
printf("\n");
}
//printf("*****************************\n");
}
void tian(int a, int b, int x, int y)//填数字，并且把周围的格子出现这个数字的可能性去掉,x表示斜杠上的数字，y表示斜杠下的数字
{
int xoff = b/3*3;
int yoff = a/2*2;
if(x != 0)
{
z[a][b].x = x;
for(int i=0;i<6;++i)
{
if(f[a][i][0][x] == 0)
--f[a][i][0][0];
f[a][i][0][x] = 1;
if(f[i][b][0][x] == 0)
--f[i][b][0][0];
f[i][b][0][x] = 1;
if(f[a][i][1][x] == 0)
--f[a][i][1][0];
f[a][i][1][x] = 1;
if(f[i][b][1][x] == 0)
--f[i][b][1][0];
f[i][b][1][x] = 1;
}
for(int i=0;i<2;++i)
{
for(int j=0;j<3;++j)
{
if(f[yoff+i][xoff+j][0][x] == 0)
--f[yoff+i][xoff+j][0][0];
f[yoff+i][xoff+j][0][x] = 1;
if(f[yoff+i][xoff+j][1][x] == 0)
--f[yoff+i][xoff+j][1][0];
f[yoff+i][xoff+j][1][x] = 1;
}
}
if(xie[a][b])
{
for(int i=x-1;i>0;--i)
{
if(f[a][b][1][i] == 0)
--f[a][b][1][0];
f[a][b][1][i] = 1;
}
}
}
if(y != 0 && x != y)
{
z[a][b].y = y;
for(int i=0;i<6;++i)
{
if(f[a][i][0][y] == 0)
--f[a][i][0][0];
f[a][i][0][y] = 1;
if(f[i][b][0][y] == 0)
--f[i][b][0][0];
f[i][b][0][y] = 1;
if(f[a][i][1][y] == 0)
--f[a][i][1][0];
f[a][i][1][y] = 1;
if(f[i][b][1][y] == 0)
--f[i][b][1][0];
f[i][b][1][y] = 1;
}
for(int i=0;i<2;++i)
{
for(int j=0;j<3;++j)
{
if(f[yoff+i][xoff+j][0][y] == 0)
--f[yoff+i][xoff+j][0][0];
f[yoff+i][xoff+j][0][y] = 1;
if(f[yoff+i][xoff+j][1][y] == 0)
--f[yoff+i][xoff+j][1][0];
f[yoff+i][xoff+j][1][y] = 1;
}
}
if(xie[a][b])
{
for(int i=y+1;i<10;++i)
{
if(f[a][b][0][i] == 0)
--f[a][b][0][0];
f[a][b][0][i] = 1;
}
}
}
}
bool judge()//判断是否得出答案
{
for(int i=0;i<6;++i)
{
for(int j=0;j<6;++j)
{
if(xie[i][j])
{
if(z[i][j].x == 0 || z[i][j].y == 0)
return false;
}
else
{
if(z[i][j].x == 0)
return false;
}
}
}
return true;
}
bool solve()
{
while(1)
{
int x=0,y=0,MIN = 9,ff = 0;
bool istian = false;
bool maodun = false;
for(int i=0;i<6;++i)
{
for(int j=0;j<6;++j)
{
if(xie[i][j])
{
if(z[i][j].x == 0)
{
if(f[i][j][0][0] == 0)
{
maodun = true;
//printf("*****(%d,%d)矛盾\n", i, j);
break;
}
else if(f[i][j][0][0] == 1)
{
for(int ii=1;ii<10;++ii)
{
if(f[i][j][0][ii] == 0)
{
tian(i,j,ii,0);
istian = true;
}
}
}
else if(f[i][j][0][0] > 1)
{
if(f[i][j][0][0] < MIN)
{
MIN = f[i][j][0][0];
x = j;
y = i;
ff = 0;
}
}
}
if(z[i][j].y == 0)
{
if(f[i][j][1][0] == 0)
{
maodun = true;
//printf("*****(%d,%d)矛盾\n", i, j);
break;
}
else if(f[i][j][1][0] == 1)
{
for(int ii=1;ii<10;++ii)
{
if(f[i][j][1][ii] == 0)
{
tian(i,j,0,ii);
istian = true;
}
}
}
else if(f[i][j][1][0] > 1)
{
if(f[i][j][1][0] < MIN)
{
MIN = f[i][j][1][0];
x = j;
y = i;
ff = 1;
}
}
}
}
else
{
if(z[i][j].x == 0)
{
if(f[i][j][0][0] == 0)
{
maodun = true;
//printf("*****(%d,%d)矛盾\n", i, j);
break;
}
else if(f[i][j][0][0] == 1)
{
for(int ii=1;ii<10;++ii)
{
if(f[i][j][0][ii] == 0)
{
tian(i,j,ii,ii);
istian = true;
}
}
}
else if(f[i][j][0][0] > 1)
{
if(f[i][j][0][0] < MIN)
{
MIN = f[i][j][0][0];
x = j;
y = i;
ff = 0;
}
}
}
}
}
if(maodun)
break;
}
//show();
if(maodun)
{
//printf("返回\n");
return false;
}
if(!istian)
{
if(judge()) return true;
node tz[10][10];
int tf[10][10][2][10];
for(int i=0;i<6;++i)
{
for(int j=0;j<6;++j)
{
tz[i][j] = z[i][j];
for(int k=0;k<2;++k)
{
for(int m=0;m<10;++m)
{
tf[i][j][k][m] = f[i][j][k][m];
}
}
}
}
for(int ii=1;ii<10;++ii)
{
if(f[y][x][ff][ii] == 0)
{
//printf("*************假设(%d,%d,%d,%d)\n", y, x, ff, ii);
if(y == 3 && x == 1 && ff == 0 && ii == 2)
ii = 2;
if(ff == 0) tian(y,x,ii,0);
else tian(y,x,0,ii);
if(solve())
return true;
for(int i=0;i<6;++i)
{
for(int j=0;j<6;++j)
{
z[i][j] = tz[i][j];
for(int k=0;k<2;++k)
{
for(int m=0;m<10;++m)
{
f[i][j][k][m] = tf[i][j][k][m];
}
}
}
}
}
}
return false;
}
}
return true;
}
int main()
{
scanf("%d", &T);
while(T--)
{
int CASE;
scanf("%d", &CASE);
MS(z, 0);
MS(f, 0);
MS(xie, 0);
for(int i=0;i<6;++i)
{
for(int j=0;j<6;++j)
{
f[i][j][0][0] = f[i][j][1][0] = 9;
}
}
for(int i=0;i<6;++i)
{
for(int j=0;j<6;++j)
{
scanf("%s", s);
int len = strlen(s);
if(len == 1 && s[0] != '-')
{
tian(i,j,s[0]-'0',s[0]-'0');
}
if(len == 3)
{
xie[i][j] = 1;
tian(i,j,s[0]=='-'?0:s[0]-'0',s[2]=='-'?0:s[2]-'0');
}
}
int t = 0;
}
//show();
solve();
printf("%d\n", CASE);
show();
}
return 0;
}1971: 安排座位
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=100005;
int a[maxn],b[maxn];
bool cmp(int a,int b)
{
return a>b;
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
int n;
scanf("%d",&n);
for(int i=0;i<n;i++) scanf("%d",a+i);
for(int i=0;i<n;i++) scanf("%d",b+i);
sort(a,a+n,cmp);
sort(b,b+n);
int ans=0;
for(int i=0;i<n;i++) ans+=(a[i]-b[i])*(a[i]-b[i]);
printf("%d\n",ans);
}
return 0;
}1972: 大梵天的恩赐
#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long int LL;
const int maxn=1234567+1;
const int mod=233333333;
int ans[maxn]={0,2};
int main()
{
for(int i=2;i<=1234567;i++)
{
ans[i]=(2*ans[i-1]+2)%mod;
}
int n;
while(scanf("%d",&n)!=EOF)
{
int res1=ans[n];
int res2=(ans[n]*2-1)%mod;
printf("%d %d\n",res1,res2);
}
return 0;
}1973: 给自己出题的小X
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=50;
int a[MAXN];
int ans,n;
void dfs(int pos,int k,int gap)
{
if(pos==n||gap<=k+1) return;
for(int i=pos+1;i<=n;i++)
{
if(a[i]-a[pos]>k+1)
{
dfs(i,k+1,min(gap,a[i]-a[pos]));
ans++;
}
}
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
ans=0;
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
sort(a+1,a+n+1);
for(int i=1;i<=n;i++)
dfs(i,1,INF);
printf("%d\n",ans);
}
return 0;
}1974: 神奇药水
#include<iostream>
#include<cstdio>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<cmath>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const double eps=1e-6;
const int MAXN=50;
typedef pair<double,double> PDD;
set<PDD> s;
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
s.clear();
int op;
double x,y;
for(int i=1;i<=n;i++)
{
scanf("%d%lf%lf",&op,&x,&y);
PDD tmp=make_pair(x,y);
if(op==0)
{
if(!s.empty())
{
auto p=s.begin(),q=s.end();q--;
if(!s.empty()&&(*p).first<=x&&(*q).first>=x)
printf("Yes\n");
else printf("No\n");
}else
{
printf("No\n");
}
}else if(op==1)
{
s.insert(tmp);
}else
{
auto p=s.find(tmp);
if(p!=s.end())
{
s.erase(p);
}
}
}
}
return 0;
}1975: 机器人搬重物
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int maxn=55;
char c;
int a[maxn][maxn],n,m,sx,sy,ex,ey,sd;
int dy[4]={1,0,-1,0};
int dx[4]={0,1,0,-1};
bool vis[maxn][maxn][5];
struct node
{
int x,y,d,step;//用d（0、1、2、3、4）表示不同朝向
bool operator < (const node &a) const{
return a.step<step;
}
};
priority_queue<node> q;
//queue<node> q;
bool check(int x,int y)
{
if(x>=n||y>=m||x<=0||y<=0)
return false;
if(a[x][y]==1||a[x+1][y]==1||a[x][y+1]==1||a[x+1][y+1]==1)
return false;
return true;
}
void bfs()
{
memset(vis,false,sizeof(vis));
node now,next;
now.x = sx;
now.y = sy;
now.d = sd;
now.step = 0;
if(!check(sx,sy))
{
printf("-1\n");
return ;
}
if(!check(ex,ey))
{
printf("-1\n");
return ;
}
while(!q.empty()) q.pop();
q.push(now);
vis[sx][sy][sd] = true;
while(!q.empty())
{
now = q.top();
q.pop();
//printf("%d %d %d %d\n",now.x,now.y,now.d,now.step);
if(now.x==ex&&now.y==ey)
{
printf("%d\n",now.step);
return ;
}
for(int step=1;step<=3;step++)
{
next.x = now.x+dx[now.d]*step;
next.y = now.y+dy[now.d]*step;
next.d = now.d;
if(check(next.x,next.y)&&vis[next.x][next.y][next.d]==false)
{
next.step = now.step+1;
q.push(next);
vis[next.x][next.y][next.d] = true;
}
else//如果1 2 3某一个不能走，那后面的肯定不能走
{
break;
}
}
if(vis[now.x][now.y][(now.d+1)%4]==false)//ÓÒת
{
next.x = now.x;
next.y = now.y;
next.d = (now.d+1)%4;
next.step = now.step+1;
q.push(next);
vis[next.x][next.y][next.d] = true;
}
if(vis[now.x][now.y][(now.d-1+4)%4]==false)//×óת
{
next.x = now.x;
next.y = now.y;
next.d = (now.d-1+4)%4;
next.step = now.step+1;
q.push(next);
vis[next.x][next.y][next.d] = true;
}
}
printf("-1\n");
}
int main()
{
while(scanf("%d %d",&n,&m)!=EOF)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
scanf("%d\n",&a[i][j]);
}
}
scanf("%d %d %d %d",&sx,&sy,&ex,&ey);
getchar();
scanf("%c",&c);
if(sx==ex&&sy==ey)
{
printf("0\n");
continue;
}
if(c=='E') sd=0;
else if(c=='S') sd=1;
else if(c=='W') sd=2;
else if(c=='N') sd=3;
bfs();
}
}1976: 搬运工小明
#include<iostream>
#include<cstdio>
#include<string.h>
#include<algorithm>
using namespace std;
long long a[100010];
int main()
{
int T;
cin>>T;
while(T--)
{
int N,M;
cin>>N>>M;
memset(a,0,sizeof(a));
long long maxm=0;
for(int i=1;i<=M;i++)
{
cin>>a[i];
maxm=a[i]>maxm?a[i]:maxm;
}
if(N>=M)
{
cout<<maxm<<endl;
continue;
}
while(maxm)
{
int cnt=0;
long long sum=0;
for(int i=1;i<=M;i++)
{
sum=sum+a[i];
if(sum<maxm)
{
if(i==M)
{
cnt++;
sum=0;
}
continue;
}
else if(sum==maxm)
{
cnt++;
sum=0;
}
else if(sum>maxm)
{
cnt++;
i--;
sum=0;
}
}
if(cnt<=N)
{
cout<<maxm<<endl;
break;
}
else
maxm++;
}
}
return 0;
}1977: Bit-reversal Permutation
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<map>
#include<cstring>
using namespace std;
typedef long long LL;
const int MAXN=2e5+10;
int a[MAXN];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
memset(a,0,sizeof(a));
int n;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
//cout<<log2(100000)<<endl;
//cout<<pow(2,17)<<endl;
int t=1;
int m=0;
while(t<n)
{
t*=2;
m++;
}
//cout<<m<<endl;
//cout<<(1<<m)<<endl;
bool flag=true;
for(int i=0;i<(1<<m);i++)
{
//cout<<"-----"<<i<<endl;
int tmp=i;
int sum=0;
for(int j=1;j<=m;j++)
{
sum=sum<<1;
//cout<<"tmp&1:"<<(tmp&1)<<endl;
sum=sum|(tmp&1);
tmp=tmp>>1;
//cout<<"sum: "<<sum<<endl;
}
if(!flag) printf(" ");
else flag=false;
printf("%d",a[sum]);
//cout<<sum<<endl;
}
printf("\n");
}
return 0;
}1978: LXX的图论题
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<cmath>
using namespace std;
int N,M;
double nmap[505][505];
void init()
{
for(int i=1;i<N+3;i++)
for(int j=1;j<N+3;j++)
nmap[i][j]=10000;
}
int main()
{
int u,v;
double w;
while(cin>>N>>M)
{
init();
bool suc=false;
for(int i=0;i<M;i++)
{
cin>>u>>v>>w;
nmap[u][v]=min(nmap[u][v],w); //都是有向边
}
for(int i=1;i<=N;i++)
for(int j=1;j<=N;j++)
for(int k=1;k<=N;k++)
{
if(nmap[j][k]>nmap[j][i]*nmap[i][k])
nmap[j][k]=nmap[j][i]*nmap[i][k];
}
for(int i=1;i<=N;i++) //检查有没有环满足条件
if(nmap[i][i]<1)
{
suc=true;
break;
}
if(suc)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
return 0;
}1979: 古怪的行列式
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
typedef long long ll;
using namespace std;
const int maxn = 10;
int T, n;
ll myints[] = {0,1,2,3,4,5,6,7}, sample[maxn][maxn];
ll checkSgn(){ // 计算逆序数。
int cnt = 0;
for(int i = 0; i < n-1; i++)
for(int j = i+1; j < n; j++)
if(myints[j] < myints[i])
cnt++;
if(cnt & 1)
return -1;
return 1;
}
int main(){
#ifdef TEST
freopen("test.txt", "r", stdin);
#endif // TEST
cin >> T;
while(T--){
cin >> n;
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
cin >> sample[i][j];
ll res = 0;
do{
ll temp = 1;
for(int i = 0; i < n; i++){
temp *= sample[i][myints[i]];
if(i >= 2)
if(sample[i][myints[i]] == 82 && sample[i-1][myints[i-1]] == 83 && sample[i-2][myints[i-2]] == 83){
temp /= (82*83*83);
}
}
temp *= checkSgn(); // 将一次排列得出的结果乘上1或-1.
res += temp;
}while(next_permutation(myints, myints+n));
cout << res << endl;
}
return 0;
}1980: 不堪重负的树
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long LL;
const int maxn=200+5;
const LL INF=1ll<<50;
LL sum[maxn],dp[maxn][maxn],a[maxn],c[maxn];
int n,b[maxn];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
for(int i=1;i<=n;++i)scanf("%lld",a+i);
for(int i=1;i<=n;++i)scanf("%d",b+i);
for(int i=1;i<=n;++i)c[i]=a[b[i]];
for(int i=1;i<=n;++i)sum[i]=sum[i-1]+c[i];
for(int i=1;i<=n;++i)
for(int j=i+1;j<=n;++j)
dp[i][j]=INF;
for(int i=1;i<=n;++i)dp[i][i]=c[i];
for(int j=2;j<=n;++j)
{
for(int i=j-1;i>0;--i)
{
dp[i][j]=min(dp[i][j-1],dp[i+1][j])+sum[j]-sum[i-1];
for(int k=i+1;k<=j-1;++k)
{
dp[i][j]=min(dp[i][j],dp[i][k-1]+sum[j]-sum[i-1]+dp[k+1][j]);
}
}
}
printf("%lld\n",dp[1][n]);
}
return 0;
}1981: 小M的魔术表演
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int MAXN=2e5+5;
int n,m,cnt,root[MAXN],a[MAXN],x,y,k;
struct node
{
int l,r,sum;
}T[MAXN*30];
vector<int> v;
int getid(int x)
{
return lower_bound(v.begin(),v.end(),x)-v.begin()+1;
}
//update(1,n,root[i],root[i-1],getid(a[i]));
void update(int l,int r,int &x,int y,int pos)
{
T[++cnt]=T[y],T[cnt].sum++,x=cnt;
if(l==r) return;
int mid=(l+r)>>1;
if(mid>=pos) update(l,mid,T[x].l,T[y].l,pos);
else update(mid+1,r,T[x].r,T[y].r,pos);
}
//query(1,n,root[x-1],root[y],k)
int query(int l,int r,int x,int y,int k)
{
if(l==r) return T[y].sum-T[x].sum;
int mid=(l+r)>>1;
int sum=T[T[y].l].sum-T[T[x].l].sum;
if(mid>=k) return query(l,mid,T[x].l,T[y].l,k);
else return sum+query(mid+1,r,T[x].r,T[y].r,k);
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d%d",&n,&m);
v.clear();
cnt=0;
memset(root,0,sizeof(root));
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
v.push_back(a[i]);
}
sort(v.begin(),v.end());
v.erase(unique(v.begin(),v.end()),v.end());
int len=v.size();
for(int i=1;i<=n;i++)
{
update(1,n,root[i],root[i-1],getid(a[i]));
}
while(m--)
{
scanf("%d%d%d",&x,&y,&k);
int pos=getid(k);
//cout<<"pos: "<<pos<<endl;
if(pos>len)
{
printf("%d\n",y-x+1);
}else
{
if(pos==1)
{
printf("0\n");
}else
{
pos--;
printf("%d\n",query(1,n,root[x-1],root[y],pos));
}
}
}
}
return 0;
}1982: 小M的移动硬盘
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
#define MAXN 300010
typedef long long ll;
int m, n;
int l[MAXN], r[MAXN];
void init()
{
r[0] = 1;
l[n + 1] = n;
for (int i = 1; i <= n; i++)
{
l[i] = i - 1;
r[i] = i + 1;
}
}
void con(int x, int y)
{
r[x] = y;
l[y] = x;
}
int main()
{
int T,x,u,v;
while (cin >> T)
{
while (T--)
{
cin >> n >> m;
init();
for (int i = 0; i < m; i++)
{
cin >> x;
if (x == 1)
{
cin >> u;
if (r[0] == u)
continue;
int l_u = l[u],r_u=r[u],r0=r[0];
con(l_u, r_u);
con(u, r0);
con(0, u);
}
else if (x == 2)
{
cin >> u;
if (l[n+1] == u)
continue;
int l_u = l[u], r_u = r[u], l_n = l[n+1];
con(l_u, r_u);
con(l_n, u);
con(u, n+1);
}
else
{
cin >> u >> v;
if (r[v] == u)
continue;
int l_u = l[u], r_u = r[u], r_v = r[v];
con(l_u, r_u);
con(u, r_v);
con(v, u);
}
}
int temp = r[0];
cout << temp;
while (r[temp] != (n + 1))
{
cout << " " << r[temp];
temp = r[temp];
}
cout << endl;
}
}
return 0;
}1985: 驱R符
#include<cstdio>
#include<cstring>
#define maxl 50010
long long n;
long long f[maxl],dec[maxl];
int main()
{
for(long long i=1;i<=50000;i++)
dec[i]=dec[i-1]+i*(i-1);
for(long long i=4;i<=50000;i++)
{
n=i-3;
f[i]=f[i-1]+(n+1)*n/2*n-dec[n];
}
int t;
scanf("%d",&t);
for(int i=1;i<=t;i++)
{
scanf("%lld",&n);
printf("%lld\n",f[n]);
}
return 0;
}1987: 绚丽的手链
#include <iostream>
#include <cstring>
#include <cstdio>
#include<algorithm>
using namespace std;
int pos, ans;
struct node
{
int num;
int child[2];
}tree[10000010];
int add()
{
pos++;
tree[pos].num = 0;
for (int i = 0; i<2; i++)
{
tree[pos].child[i] = -1;
}
return pos;
}
int inser(char* str)
{
int post = 0;
int tmp = 0;
int len = strlen(str);
for (int i = 0; i<len; i++)
{
int m = str[i] - '0';
if (tree[post].child[m] == -1)
{
if (tmp == 0)
tmp = i + 1;
tree[post].child[m] = add();
}
post = tree[post].child[m];
tree[post].num++;
ans = max(ans, tree[post].num*(i + 1));
}
if (!tmp)
tmp = len;
return tmp;
}
char arr[1000010];
int main()
{
int T;
scanf("%d", &T);
for (int t = 1; t <= T; t++)
{
int n;
pos = 0;
memset(tree[0].child, -1, sizeof(tree[0].child));
scanf("%d", &n);
ans = 0;
for (int i = 0; i<n; i++)
{
scanf("%s", &arr);
int k = inser(arr);
}
cout << ans << endl;
}
return 0;
}1991: Timo's mushrooms
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=100010;
const int maxm=100010;
struct edge_t
{
int v,next;
}edge[maxm],newedge[maxn];
int Ecnt,newEcnt;
int vertex[maxn],newvertex[maxn];
int Low[maxn],DFN[maxn],Stack[maxn],Belong[maxn];
int Index,top;
int scc;
bool Instack[maxn];
void init_Graph()
{
Ecnt=newEcnt=0;
memset(vertex,-1,sizeof(vertex));
memset(newvertex,-1,sizeof(newvertex));
}
void make_edge(int u,int v)
{
edge[Ecnt].v=v;
edge[Ecnt].next=vertex[u];
vertex[u]=Ecnt++;
}
void make_newedge(int u,int v)
{
newedge[newEcnt].v=v;
newedge[newEcnt].next=newvertex[u];
newvertex[u]=newEcnt++;
}
void Tarjan(int u)
{
int v;
Low[u]=DFN[u]=++Index;
Stack[top++]=u;
Instack[u]=true;
for(int i=vertex[u];i!=-1;i=edge[i].next)
{
v=edge[i].v;
if(!DFN[v])
{
Tarjan(v);
if(Low[u]>Low[v]) Low[u]=Low[v];
}
else if(Instack[v]&&Low[u]>DFN[v])
Low[u]=DFN[v];
}
if(Low[u]==DFN[u])
{
scc++;
do
{
v=Stack[--top];
Instack[v]=false;
Belong[v]=scc;
}
while(v!=u);
}
}
void solve(int n)
{
memset(DFN,0,sizeof(DFN));
memset(Instack,false,sizeof(Instack));
Index=scc=top=0;
for(int i=1;i<=n;i++)
if(!DFN[i])
Tarjan(i);
}
int linker[maxn];
bool used[maxn];
bool dfs(int u)
{
for(int i=newvertex[u];i!=-1;i=newedge[i].next)
{
int v=newedge[i].v;
if(!used[v])
{
used[v]=true;
if(linker[v]==-1||dfs(linker[v]))
{
linker[v]=u;
return true;
}
}
}
return false;
}
int hungary()
{
int res=0;
memset(linker,-1,sizeof(linker));
for(int u=1;u<=scc;u++)
{
memset(used,false,sizeof(used));
if(dfs(u)) res++;
}
return res;
}
//缩点建立新图
void Build_newmap(int n)
{
for(int u=1;u<=n;u++)
for(int i=vertex[u];i!=-1;i=edge[i].next)
{
int v=edge[i].v;
if(Belong[u]!=Belong[v])
make_newedge(Belong[u],Belong[v]);
}
}
int main()
{
int t;
int n,m;
int u,v;
scanf("%d",&t);
while(t--)
{
init_Graph();
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++)
{
scanf("%d%d",&u,&v);
make_edge(u,v);
}
solve(n);
Build_newmap(n);
printf("%d\n",scc-hungary());
}
return 0;
}1993: 大司马的三角形中单
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
long long dp[13][10][2],num[13];
long long dfs(int len,int x,bool tp,bool lim)
{
if (len==1) if (tp) return 0; else return 1LL; //如果len为1，而且居然还是出现了转折点，那么显然转折点是其本身
if (!lim&&dp[len][x][tp]>-1) return dp[len][x][tp]; //而这显然不合法故返回0，否则返回1有解
long long res=0;
if (tp)
{
int up=lim?num[len-1]:9;
for(int i=x+1;i<=up;i++)
res+=dfs(len-1,i,1,lim&&i==up);
if (len>2) //设前一位是转折点的情况，如此len-1必须大于1
for(int i=x+1;i<=up;i++)
res+=dfs(len-1,i,0,lim&&i==up);
} else
{
long long up1=x==0?0:x-1; //如果当前位置已经是0，那么上届是0而不是-1
int up=lim?min(num[len-1],up1):up1;
for(int i=0;i<=up;i++)
res+=dfs(len-1,i,0,lim&&i==num[len-1]);
}
if (!lim) dp[len][x][tp]=res;
return res;
}
long long cal(long long n)
{
long long res=0,len=0;
memset(dp,-1,sizeof(dp));
while(n)
{
num[++len]=n%10;
n/=10;
}
for(int i=3;i<=len;i++) //枚举长度
{
int up=i==len?num[i]:9;
for(int j=1;j<=up;j++) //枚举第一位放的数字
res+=dfs(i,j,1,i==len&&j==up);
}
return res;
}
int main()
{
long long n,m;
int T_T; scanf("%d",&T_T);
while(T_T--)
{
scanf("%lld%lld",&n,&m);
printf("%lld\n",cal(m)-cal(n-1));
}
return 0;
}1997: Seating Arrangement
#include<stdio.h>
#include<string.h>
using namespace std;
int main()
{
int i,j;
int n,d;
while(~scanf("%d%d",&n,&d))
{
if(d>n/2-1)
printf("-1\n");
else
{
int t = n/2;
if(n%2)
t = t+1;
for(i = t,j= 1;j<=n;j++)
{
if(i!=t) printf(" ");
printf("%d",i);
if(j%2) i = i + n/2;
else i = i - (n/2+1);
}
printf("\n");
}
}
return 0;
} 2005: Nearest Maintenance Point
#include<cstdio>
#include<cstring>
#include<queue>
#include<bitset>
#include<vector>
#include<algorithm>
#define INF 0x3f3f3f3f
#define N 10100
using namespace std;
int d[N],m,n,s,q,a[N],ans[N];
typedef pair<int,int> P;
struct Edge{int y,w;};
vector<Edge> g[N];
bitset<1010> p[N]; //最多1000个关键点，用关键点的序号来对应每一位
inline void dijkstra()
{
priority_queue<P,vector<P>,greater<P> > q;
for(int i=1;i<=n;i++)
{d[i]=INF;p[i].reset();}
for(int i=1;i<=s;i++) //初始时多个起点，并赋值好bitset的状态
{
q.push(P{0,a[i]});
p[a[i]][i]=1; d[a[i]]=0;
}
while (!q.empty())
{
int w=q.top().first;
int j=q.top().second;
q.pop(); if (w>d[j]) continue;
for(int k=0;k<g[j].size();k++)
{
int y=g[j][k].y;
int dist=w+g[j][k].w;
if (d[y]>dist)
{
d[y]=dist; p[y]=p[j]; //如果是大于，那么直接赋值覆盖原来的
q.push(P(d[y],y));
} else if (d[y]==dist) p[y]|=p[j]; //如果相等，那么用或来继承状态
}
}
}
int main()
{
while(~scanf("%d%d%d%d",&n,&m,&s,&q))
{
memset(g,0,sizeof(g));
for(int i=1;i<=m;i++)
{
int u,v,w;
scanf("%d%d%d",&u,&v,&w);
g[u].push_back(Edge{v,w});
g[v].push_back(Edge{u,w});
}
for(int i=1;i<=s;i++)
scanf("%d",&a[i]);
sort(a+1,a+1+s); //要求关键点升序输出
dijkstra();
while(q--)
{
int x,tot=0; scanf("%d",&x);
for(int i=1;i<=s;i++)
if (p[x][i]) ans[++tot]=a[i]; //判断对应位置是否能以最短路到达
for(int i=1;i<tot;i++)
printf("%d ",ans[i]);
printf("%d\n",ans[tot]);
}
}
return 0;
}2007: Football Training Camp
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <time.h>
#include <limits.h>
#include <assert.h>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <vector>
using namespace std;
#define pb push_back
#define vi vector<int>
#define LL long long
#define pi pair<int,int>
#define MEM(a) memset(a,0,sizeof(a));
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define lowbit(x) ((x)&-(x))
#define SI(a) ((a).size())
#define MAX 25
#define INF (0x3f3f3f3f)
#define F (1000000007)
int n, maxans, minans;
priority_queue <pi> que;
int main(int argc, char const *argv[])
{
// freopen("data.in", "r", stdin);
while (~scanf("%d", &n)) {
while (!que.empty()) que.pop();
int tot = 0 , sum = 0;
Rep(i, n) {
int score; scanf("%d", &score);
que.push(make_pair(score, 0));
sum += score;
}
minans = INF ,maxans = 0, tot = 0;
while (1) {
pi x = que.top();que.pop();
if (sum % 2 == 0 && 2 * x.first <= sum) {
maxans = max(maxans,tot+sum/2);
minans = min(minans,tot+sum/2);
}
if(x.first < 3) break;
que.push(make_pair(x.first-3,x.second+1));
tot++;
sum-=3;
}
printf("%d %d\n", minans, maxans);
}
return 0;
}2015
同2022
2017: Highest Tower
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<map>
#define LL long long
#define N 500010
using namespace std;
vector<int> g[N];
map<int,int> mp;
int n,m,val[N];
LL res,ans;
bool v[N];
void dfs(int x,int &edge,int &vertex,int &bi)
{
v[x]=1;
edge+=g[x].size()-1;
vertex++;bi=max(bi,val[x]);
res+=(LL)val[x]*(g[x].size()-1);
for(int i=0;i<g[x].size();i++)
if (!v[g[x][i]]) dfs(g[x][i],edge,vertex,bi);
}
int main()
{
while(~scanf("%d",&n))
{
ans=m=0; mp.clear();
memset(v,0,sizeof(v));
memset(g,0,sizeof(g));
for(int i=1;i<=n;i++)
{
int u,v;
scanf("%d%d",&u,&v);
if (!mp[u]) mp[u]=++m,val[m]=u;
if (!mp[v]) mp[v]=++m,val[m]=v;
g[mp[u]].push_back(mp[v]);
g[mp[v]].push_back(mp[u]);
}
for(int i=1;i<=m;i++)
if (!v[i])
{
res=0; int edge,vertex,bi;
dfs(i,edge=1,vertex=0,bi=0);
if (edge<vertex) res+=(LL)bi; ans+=res;
}
printf("%lld\n",ans);
}
return 0;
}2019: Fleecing the Raffle
#include<iostream>
using namespace std;
int main(void)
{
long long n,p ;
while(cin>>n>>p)
{
double x = n/(p-1);
double ans = 1;
ans *= (double)p*x/(n+1);
for(int i = 2;i <= p+1;++i)
ans *= (double)(n-p+i)/(n + x -p+i-1);
printf("%0.8f\n",ans);
}
return 0;
}2020: Card Hand Sorting
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
using namespace std;
struct node_t{
int val;
int suit;
int idx;
}p[60];
int increas[6],ssort[6];
bool cmp(node_t &a,node_t &b){
if(a.suit==b.suit)
return (increas[a.suit]&&a.val<b.val)||(!increas[a.suit]&&a.val>b.val);
return ssort[a.suit]<ssort[b.suit];
}
int Idx[60],flag[6]={0};
int DP[60];
char s[3];
int ans,n;
int S_Int_val(char a){
if('2'<=a&&a<='9')
return a-'1';
if(a=='T') return 9;
if(a=='J') return 10;
if(a=='Q') return 11;
if(a=='K') return 12;
return 13;
}
int S_Int_suit(char a){
if(a=='s') return 1;
if(a=='h') return 2;
if(a=='d') return 3;
return 4;
}
void dfs(int rt){
if(rt==0){
sort(p,p+n,cmp);
for(int i=0;i<n;++i)
Idx[p[i].idx]=i;
DP[0]=1;
int maxn=1;
for(int i=1;i<n;++i){
DP[i]=1;
for(int j=0;j<i;++j)
if(Idx[j]<Idx[i]) DP[i]=max(DP[j]+1,DP[i]);
maxn=max(maxn,DP[i]);
}
ans=min(n-maxn,ans);
}
for(int i=1;i<=4;++i){
if(flag[i])continue;
flag[i]=1;
ssort[rt]=i;
dfs(rt-1);
flag[i]=0;
}
}
int main(){
while(~scanf("%d",&n)){
for(int i=0;i<n;++i){
scanf("%s",s);
p[i].val=S_Int_val(s[0]);
p[i].suit=S_Int_suit(s[1]);
p[i].idx=i;
}
ans=1e9;
for(int i=0;i<(1<<4);++i){
for(int j=0;j<4;++j)
increas[j+1]=((1<<j)&i)?1:0;
dfs(4);
}
printf("%d\n",ans);
}
return 0;
}2022: Artwork
#include<cstdio>
#include<cstring>
#include<vector>
#include<set>
#include<queue>
#include<stack>
#include<iostream>
typedef long long ll;
const int N=1e6+10;
using namespace std;
int X[4]={0,0,-1,1};
int Y[4]={1,-1,0,0};
struct query{int x1,y1,x2,y2;} Q[10010];
int n,m,q,f[N],num[1010][1010],p[1010][1010];
int ans[10010],tot=0; bool v[N];
int find(int x)
{
return f[x]==x?x:f[x]=find(f[x]);
}
bool check(int x,int y)
{
if (x<=0||y<=0||x>n||y>m) return 0;
return 1;
}
void work(int x,int y)
{
tot++;
f[num[x][y]]=num[x][y];
for(int k=0;k<4;k++)
{
int xx=x+X[k],yy=y+Y[k];
if (!check(xx,yy)||p[xx][yy]) continue;
if (find(num[xx][yy])==find(num[x][y])) continue;
f[find(num[xx][yy])]=find(num[x][y]); tot--;
}
}
int main(){
int no=0;
scanf("%d%d%d",&m,&n,&q);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
num[i][j]=++no,f[no]=no;
for(int i=1;i<=q;i++)
{
int x1,y1,x2,y2;
scanf("%d%d%d%d",&y1,&x1,&y2,&x2);
if (x1==x2)
{
if (y1>y2) swap(y1,y2);
for(int j=y1;j<=y2;j++) p[x1][j]++;
} else
{
if (x1>x2) swap(x1,x2);
for(int j=x1;j<=x2;j++) p[j][y1]++;
}
Q[i]=query{x1,y1,x2,y2};
}
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
if (p[i][j]) continue;
for(int k=0;k<4;k++)
{
int xx=i+X[k],yy=j+Y[k];
if (!check(xx,yy)) continue;
if (p[xx][yy]) continue;
if (find(num[xx][yy])==find(num[i][j])) continue;
f[find(num[xx][yy])]=find(num[i][j]);
}
}
memset(v,0,sizeof(v));
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
if (p[i][j]) continue;
int fa=find(num[i][j]);
if (v[fa]) continue;
v[fa]=1; tot++;
}
ans[q]=tot;
for(int k=q;k>=2;k--)
{
if (Q[k].x1==Q[k].x2)
{
for(int i=Q[k].y1;i<=Q[k].y2;i++)
if (!--p[Q[k].x1][i]) work(Q[k].x1,i);
} else
{
for(int i=Q[k].x1;i<=Q[k].x2;i++)
if (!--p[i][Q[k].y2]) work(i,Q[k].y2);
}
ans[k-1]=tot;
}
for(int i=1;i<=q;i++)
printf("%d\n",ans[i]);
return 0;
}2023: Bless You Autocorrect!
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#define N 1000010
#define file(x) freopen(#x".in","r",stdin),freopen(#x".out","w",stdout);
using namespace std;
char s[N];
int n,m;
struct Trie
{
struct node{int ch[28],cnt;}T[N];
int tot,root,d[N]; bool v[N];
void init(){tot=root=1;}
int newnode()
{
++tot;
for(int i=0;i<28;i++)
T[tot].ch[i]=0;
T[tot].cnt=0;
return tot;
}
void ins(char* x)
{
int o=root;
vector<int> point;
for(int k=0;x[k];k++)
{
int c=x[k]-'a';
if (!T[o].ch[c]) T[o].ch[c]=newnode();
if (!T[o].ch[26]&&!T[o].cnt) point.push_back(o);
T[T[o].ch[c]].ch[27]=o; o=T[o].ch[c];
}
T[o].cnt++;
for(int i=0;i<point.size();i++)
if (point[i]!=root) T[point[i]].ch[26]=o;
}
void bfs()
{
queue<int> q;
memset(v,0,sizeof(v));
q.push(root); d[root]=0; v[root]=1;
while(!q.empty())
{
int x=q.front();q.pop();
for(int i=0;i<28;i++)
{
int y=T[x].ch[i];
if (y==0||v[y]) continue;
v[y]=1; d[y]=d[x]+1; q.push(y);
}
}
}
int query(char* x)
{
int o=root,k;
for(k=0;x[k];k++)
{
int c=x[k]-'a';
if (T[o].ch[c]==0) break;
o=T[o].ch[c];
}
return d[o]+strlen(x)-k;
}
} Trie;
int main()
{
//file(x);
while(cin>>n>>m)
{
Trie.init();
while(n--)
{
scanf("%s",s);
Trie.ins(s);
}
Trie.bfs();
while(m--)
{
scanf("%s",s);
printf("%d\n",Trie.query(s));
}
puts("");
}
return 0;
}2025: Jumbled Compass
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
using namespace std;
int main(){
int n,m;
while(cin>>n>>m){
int t=m-n;
if(t<0) t+=360;
else t=t%360;
if(t<=360-t) printf("%d\n",t);
else printf("%d\n",t-360);
}
return 0;
}2026: Daydreaming Stockbroker
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <set>
using namespace std;
int main() {
int n;
while(~scanf("%d",&n)) {
set<long long>se1;
se1.insert(0);
long long Map[100002]= {};
Map[0]=100;
while(n--) {
long long temp;
scanf("%lld",&temp);
for(set<long long>::iterator it=se1.begin(); it!=se1.end(); it++) {
long long x=(*it)+Map[(*it)]/temp,y=Map[(*it)]%temp;
if(x>100000) {
y+=(x-100000)*temp;
x=100000;
}
se1.insert(x);
Map[x]=max(Map[x],y);
Map[0]=max(Map[0],Map[(*it)]+(*it)*temp);
}
}
printf("%lld\n",Map[0]);
}
return 0;
}2031: Barareh on Fire
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<iostream>
using namespace std;
const int inf=0x3f3f3f3f;
char s[105][105];
int t[105][105];
int vis[105][105];
int fx[]={1,-1,0,0,1,1,-1,-1};
int fy[]={0,0,1,-1,1,-1,1,-1};
int px[]={1,-1,0,0};
int py[]={0,0,1,-1};
int n,m,k,sx,sy;
struct node
{
int x,y,step;
}r,p,q;
queue<node> Q;
void bfs_fire()
{
int i,j;
while(!Q.empty())
{
p=Q.front();
Q.pop();
for(i=0;i<8;i++)
{
q=p;
q.x+=fx[i];
q.y+=fy[i];
q.step+=k;
if(q.x<0||q.y<0||q.x>=n||q.y>=m)
continue;
if(vis[q.x][q.y]==0)
{
vis[q.x][q.y]=1;
t[q.x][q.y]=q.step;
Q.push(q);
}
}
}
}
int bfs_people()
{
while(!Q.empty())
Q.pop();
memset(vis,0,sizeof(vis));
int i,j;
p.x=sx;
p.y=sy;
p.step=0;
vis[p.x][p.y]=1;
Q.push(p);
while(!Q.empty())
{
p=Q.front();
Q.pop();
//printf("%d %d\n",p.x,p.y);
if(s[p.x][p.y]=='t')
return p.step;
for(i=0;i<4;i++)
{
q=p;
q.x+=px[i];
q.y+=py[i];
q.step++;
if(q.x<0||q.y<0||q.x>=n||q.y>=m)
continue;
if(vis[q.x][q.y]==0&&q.step<t[q.x][q.y])
{
vis[q.x][q.y]=1;
Q.push(q);
}
}
}
return -1;
}
int main()
{
int i,j;
while(scanf("%d %d %d",&n,&m,&k)!=EOF)
{
if(n==0&&m==0&&k==0) break;
memset(t,inf,sizeof(t));
memset(vis,0,sizeof(vis));
while(!Q.empty())
Q.pop();
for(i=0;i<n;i++)
{
scanf("%s",s[i]);
for(j=0;j<m;j++)
{
if(s[i][j]=='f')
{
r.x=i;
r.y=j;
r.step=0;
t[i][j]=0;
vis[i][j]=1;
Q.push(r);
}
if(s[i][j]=='s')
{
sx=i;
sy=j;
}
}
}
bfs_fire();
int ans=bfs_people();
if(ans==-1)
printf("Impossible\n");
else
printf("%d\n",ans);
}
}2033: New Country Division
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<vector>
#include<map>
#include<queue>
#define LL long long
#define N 20010
using namespace std;
struct Linear_Basis
{
LL d[63],p[63],tot;
void init()
{
tot=0;
memset(d,0,sizeof(d));
memset(p,0,sizeof(p));
}
bool ins(LL x)
{
for(int i=62;i>=0;i--)
if (x&(1LL<<i))
{
if (!d[i]) {d[i]=x;break;}
x^=d[i];
}
return x>0;
}
LL Max(LL x)
{
LL res=x;
for(int i=62;i>=0;i--)
res=max(res,res^d[i]);
return res;
}
} LB;
int n,m;
LL w[N];
int main()
{
while(~scanf("%d%d",&n,&m))
{
if (n+m==0) break;
LB.init();
memset(w,0,sizeof(w));
for(int i=1;i<=m;i++)
{
int u,v; LL p;
scanf("%d%d%lld",&u,&v,&p);
w[u]^=p; w[v]^=p;
}
LL P=w[1];
for(int i=2;i<n;i++)
LB.ins(w[i]);
printf("%lld\n",LB.Max(P));
}
}2034: Column Addition
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
using namespace std;
char readchar(){
char cc;
cc=getchar();
while(cc=='\n'||cc=='\r'||cc==' '){
cc=getchar();
}
return cc;
}
int a[1010], b[1010], c[1010];
int dp[1010][2], n;
void read(){
for (int i=0;i<n;++i)
a[i]=readchar()-'0';
for (int i=0;i<n;++i)
b[i]=readchar()-'0';
for (int i=0;i<n;++i)
c[i]=readchar()-'0';
return ;
}
int main(){
while(scanf("%d",&n)){
if (n==0)
break;
read();
memset(dp,0,sizeof(dp));
for (int i=n-1;i>=0;--i){
if ((a[i]+b[i])%10==c[i]){
if (a[i]+b[i]>9){
dp[i][1]=dp[i+1][0]+1;
}else{
dp[i][0]=dp[i+1][0]+1;
}
}
if (dp[i+1][1]){
if ((a[i]+b[i]+1)%10==c[i]){
if ((a[i]+b[i]+1>9)){
dp[i][1]=dp[i+1][1]+1;
}else{
dp[i][0]=dp[i+1][1]+1;
}
}
}
dp[i][1]=max(dp[i+1][1],dp[i][1]);
dp[i][0]=max(dp[i+1][0],dp[i][0]);
}
printf("%d\n",n-dp[0][0]);
}
return 0;
}2035: Cafe Bazaar
#include <cstdio>
#include<map>
#include<algorithm>
#include<cstring>
#include<iostream>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define x first
#define y second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<int, LL>PIL;
typedef pair<LL, int> PLI;
typedef pair<LL, LL> PLL;
const int MX = 1e2 + 5;
const int MXM = MX * 40;
vector<PLI>ver;
struct Trie {
int nxt[MXM][2], cnt[MXM];
int root, rear;
int new_node() {
cnt[++rear] = 0;
memset (nxt[rear], 0, sizeof (nxt[rear]) );
return rear;
}
void init () {
rear = 0;
root = new_node();
}
void insert (LL x) {
int now = root, tmp;
for (int i = 40; i; i--) {
tmp = x >> (i - 1) & 1;
if (!nxt[now][tmp]) nxt[now][tmp] = new_node();
now = nxt[now][tmp];
cnt[now]++;
}
}
void query() {
dfs (root, 0, 0, -1);
}
void add (LL x, int y) {
for (int i = y + 1; i <= 40; i++) x <<= 1;
ver.push_back (PLI (x, y) );
}
bool check1 (int now, int d) {
int now1 = now, now2 = now;
for (int i = d; i <= 40; i++) {
if (nxt[now1][0] == 0 || nxt[now2][1] == 0) return 0;
now1 = nxt[now1][0];
now2 = nxt[now2][1];
}
return 1;
}
bool check2 (int now, int d, int s) {
for (int i = d; i <= 40; i++) {
if (nxt[now][s] == 0) return 0;
now = nxt[now][s];
}
return 1;
}
void dfs (int now, int d, LL val, int s) {
if (d == 40) {
add (val, d);
return;
}
if (s == -1) {
if (check1 (now, d + 1) ) {
add (val, d);
return;
}
if (nxt[now][0] && nxt[now][1]) {
dfs (nxt[now][0], d + 1, val << 1, 0);
dfs (nxt[now][1], d + 1, val << 1 | 1, 1);
} else if (nxt[now][0]) dfs (nxt[now][0], d + 1, val << 1, -1);
else dfs (nxt[now][1], d + 1, val << 1 | 1, -1);
} else {
if (check2 (now, d + 1, s) ) {
add (val, d);
return;
}
if (nxt[now][s ^ 1] == 0) add ( val << 1 | (s ^ 1), d + 1), dfs (nxt[now][s], d + 1, val << 1 | s, s);
else dfs (nxt[now][s ^ 1], d + 1, val << 1 | (s ^ 1), s);
}
}
} t;
int a[MX], n;
char str[MX];
LL code (int l, int r) {
LL ret = 0, tmp = 0;
for (int i = l; i <= r; i++) {
if (str[i] == '.' || i == r) {
ret = ret * 256 + tmp, tmp = 0;
continue;
}
tmp = tmp * 10 + str[i] - '0';
}
return ret;
}
bool cmp1 (const PLL& p1, const PLL& p2) {
if (p1.x != p2.x) return p1.x < p2.x;
return p1.y > p2.y;
}
bool cmp2 (const PLI& p1, const PLI& p2) {
return p1.x < p2.x;
}
PLL p[MX];
void print (LL x, int y) {
for (int i = 4; i >= 0; i--) {
LL tmp = x >> (8 * i) & 255;
printf ("%lld%c", tmp, i == 0 ? '/' : '.');
}
printf ("%d\n", y);
}
int main() {
//freopen ("in.txt", "r", stdin);
while (~scanf ("%d", &n), n) {
ver.clear();
for (int i = 0, j; i < n; i++) {
scanf ("%s", str);
int len = strlen (str);
for (j = 0; j < len; j++) if (str[j] == '-' || str[j] == '/') break;
LL l, r;
if (str[j] == '-') {
l = code (0, j), r = code (j + 1, len);
} else {
l = r = code (0, j);
int cnt = 0;
for (++j; j < len; j++) cnt = cnt * 10 + str[j] - '0';
for (int i = cnt + 1; i <= 40; i++) r |= (1LL << (40 - i) );
}
p[i] = PLL (l, r);
}
sort (p, p + n, cmp1);
int pre = 0;
for (int i = 1; i < n; i++) {
if (p[i].x - 1 <= p[pre].y) p[pre].y = max (p[pre].y, p[i].y);
else p[++pre] = p[i];
}
for (int i = 0; i <= pre; i++) t.init(), t.insert (p[i].x), t.insert (p[i].y), t.query();
sort (ver.begin(), ver.end(), cmp2);
printf ("%d\n", ver.size() );
for (auto f : ver) print (f.x, f.y);
}
return 0;
}2036: Getting Back Home
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
#define N 30010
using namespace std;
int d[N],deep[N],n;
vector<int> g[N];
bool v[N];
void dfs(int x,int fa,int dep)
{
d[x]=dep;
deep[x]=0;
v[x]=(x==1);
for(int i=0;i<g[x].size();i++)
{
int y=g[x][i];
if (y==fa) continue;
dfs(y,x,dep+1); v[x]|=v[y];
deep[x]=max(deep[x],deep[y]+1);
}
}
void getsub(int x,int fa,int &sub)
{
int fir=0,sec=0;
for(int i=0;i<g[x].size();i++)
{
int y=g[x][i];
if (y==fa) continue;
if (deep[y]+1>fir)
{
sec=fir,fir=deep[y]+1;
sub=max(sec,sub);
} else
{
sec=max(sec,deep[y]+1);
sub=max(sec,sub);
}
getsub(y,x,sub);
}
}
void solve(int x,int fa,int &k,int c)
{
if (x==1) return;
if (d[1]-d[x]<k) return;
int fir=0,sec=0,nxt,z;
for(int i=0;i<g[x].size();i++)
{
int y=g[x][i];
if (fa==y) continue;
if (v[y]) {nxt=y;continue;}
if (deep[y]+1>fir) sec=fir,fir=deep[y]+1,z=y;
else sec=max(sec,deep[y]+1);
}
int h=d[1]-d[x];
if (fir)
{
int sub=0;
int tmp=max(c,sec);
if (tmp<fir)
{
getsub(z,x,sub);
tmp=max(tmp,sub);
if (tmp) k=max(k,tmp+1);
} else k=max(k,fir+1);
k=min(k,h);
}
solve(nxt,x,k,max(fir,c)+1);
}
int main()
{
while(~scanf("%d",&n))
{
if (n==0) break;
for(int i=0;i<=n;i++) g[i].clear();
for(int i=1;i<n;i++)
{
int u,v;
scanf("%d%d",&u,&v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(n,0,0);
int ans=0;
solve(n,0,ans,0);
printf("%d\n",ans);
}
}2037: Mars
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<vector>
#include<map>
#include<queue>
#define N 20010
using namespace std;
struct Suffix_Automation
{
int tot,cur;
struct node{int ch[2],len,fa;} T[N];
void init(){cur=tot=1;memset(T,0,sizeof(T));}
void ins(int x,int id)
{
int p=cur;cur=++tot;T[cur].len=id;
for(;p&&!T[p].ch[x];p=T[p].fa) T[p].ch[x]=cur;
if (!p) {T[cur].fa=1;return;}int q=T[p].ch[x];
if (T[p].len+1==T[q].len){T[cur].fa=q;return;}
int np=++tot; memcpy(T[np].ch,T[q].ch,sizeof(T[q].ch));
T[np].fa=T[q].fa; T[q].fa=T[cur].fa=np; T[np].len=T[p].len+1;
for(;p&&T[p].ch[x]==q;p=T[p].fa) T[p].ch[x]=np;
}
} SAM;
struct node{int pos,t,i;};
char s[N],st[N];
int n,m,len,ans;
void dfs(int x,int pos,int t)
{
if (t>=ans) return;
if (x>=len) return;
int ch=st[x]-'0';
int nxt=SAM.T[pos].ch[ch];
if (nxt==0) ans=min(ans,t);
else dfs(x+1,nxt,t);
nxt=SAM.T[pos].ch[ch^1];
if (nxt==0) ans=min(ans,t+1);
else dfs(x+1,nxt,t+1);
}
int main()
{
while(~scanf("%d%d",&n,&m))
{
SAM.init();
if (n+m==0) break;
scanf("%s",s);
for(int i=0;s[i];i++)
SAM.ins(s[i]-'0',i+1);
while(m--)
{
int a,b;
ans=0x3f3f3f3f;
scanf("%d %d",&a,&b);
len=b-a+1; a--; b--;
for(int i=0;i<len;i++)
st[i]=s[a+i];
st[b-a+1]='\0'; dfs(0,1,0);
if (ans==0x3f3f3f3f) puts("Impossible");
else printf("%d\n",ans);
}
}
}
扫一扫
326
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
