Codeforces Round #199 (Div. 2)

-----------------------------

A. Xenia and Divisors

---

将n个数3个一组分成满足条件的n/3组。

由于数字最多是7，所以只有124、126、136三种分组方式。

先分出所有的136，再分出124，126。若所有数字都用光则分组成功。

---

#include <iostream>

using namespace std;
int n;
int a[10]={0};
bool check(){
for (int i=1;i<=7;i++) if (a[i]<0) return true;
return false;
}

int main()
{
cin>>n;
for (int i=0;i<n;i++){
int t;
cin>>t;
a[t]++;
}
if (n%3!=0){
cout<<-1<<endl;
return 0;
}
if (a[5]>0||a[7]>0){
cout<<-1<<endl;
return 0;
}
int c1,c2,c3;
c1=a[3];
a[1]-=c1;
a[3]-=c1;
a[6]-=c1;
if (check()){
cout<<-1<<endl;
return 0;
}
c2=a[6];
a[1]-=c2;
a[2]-=c2;
a[6]-=c2;
if (check()){
cout<<-1<<endl;
return 0;
}
c3=a[4];
a[1]-=c3;
a[2]-=c3;
a[4]-=c3;
if (check()){
cout<<-1<<endl;
return 0;
}
if (c1*3+c2*3+c3*3!=n){
cout<<-1<<endl;
return 0;
}
for (int i=1;i<=7;i++) if (a[i]!=0) {
cout<<-1<<endl;
return 0;
}
for (int i=0;i<c3;i++) cout<<"1 2 4"<<endl;
for (int i=0;i<c2;i++) cout<<"1 2 6"<<endl;
for (int i=0;i<c1;i++) cout<<"1 3 6"<<endl;
return 0;
}

-----------------------------

B. Xenia and Spies

---

n个人，s要将纸条传到f。传一次用时1。

有m次观察，对于每次观察，第t秒时区间[l,r]不能传递或接受纸条。

问最少用多少时间才能将纸条传到f。

贪心传递即可，若能传递则尽可能传递。

若m次观察后还没有传到f，则要继续传到f。

---

/** head-file **/

#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <set>
#include <map>
#include <algorithm>

/** define-for **/

#define REP(i, n) for (int i=0;i<int(n);++i)
#define FOR(i, a, b) for (int i=int(a);i<int(b);++i)
#define DWN(i, b, a) for (int i=int(b-1);i>=int(a);--i)
#define REP_1(i, n) for (int i=1;i<=int(n);++i)
#define FOR_1(i, a, b) for (int i=int(a);i<=int(b);++i)
#define DWN_1(i, b, a) for (int i=int(b);i>=int(a);--i)
#define REP_N(i, n) for (i=0;i<int(n);++i)
#define FOR_N(i, a, b) for (i=int(a);i<int(b);++i)
#define DWN_N(i, b, a) for (i=int(b-1);i>=int(a);--i)
#define REP_1_N(i, n) for (i=1;i<=int(n);++i)
#define FOR_1_N(i, a, b) for (i=int(a);i<=int(b);++i)
#define DWN_1_N(i, b, a) for (i=int(b);i>=int(a);--i)

/** define-useful **/

#define clr(x,a) memset(x,a,sizeof(x))
#define sz(x) int(x.size())
#define see(x) cerr<<#x<<" "<<x<<endl
#define se(x) cerr<<" "<<x
#define pb push_back
#define mp make_pair

/** test **/

#define Display(A, n, m) {                      \
REP(i, n){                                  \
REP(j, m) cout << A[i][j] << " ";       \
cout << endl;                           \
}                                           \
}

#define Display_1(A, n, m) {                    \
REP_1(i, n){                                \
REP_1(j, m) cout << A[i][j] << " ";     \
cout << endl;                           \
}                                           \
}

using namespace std;

/** typedef **/

typedef long long LL;

/** Add - On **/

const int direct4[4][2]={ {0,1},{1,0},{0,-1},{-1,0} };
const int direct8[8][2]={ {0,1},{1,0},{0,-1},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1} };
const int direct3[6][3]={ {1,0,0},{0,1,0},{0,0,1},{-1,0,0},{0,-1,0},{0,0,-1} };

const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long INFF = 1LL << 60;
const double EPS = 1e-9;
const double OO = 1e15;
const double PI = acos(-1.0); //M_PI;
int n,m,s,f;
struct QAQ{
int t,l,r;
}a[211111];

bool check(int x,int l,int r){
if (x>=l&&x<=r) return true;
return false;
}
int u;
vector<char>vec;
int main()
{
vec.clear();
cin>>n>>m>>s>>f;
u=1;
REP(i,m) cin>>a[i].t>>a[i].l>>a[i].r;
REP(i,m){
int t,l,r;
t=a[i].t;
l=a[i].l;
r=a[i].r;
while (u<t){
if (s<f) vec.push_back('R'),s++;
if (s>f) vec.push_back('L'),s--;
if (s==f) break;
u++;
}
if (s==f) break;
if (check(s,l,r)){
vec.push_back('X');
}
else if (s<f&&check(s+1,l,r)){
vec.push_back('X');
}
else if (s>f&&check(s-1,l,r)){
vec.push_back('X');
}
else{
if (s<f) vec.push_back('R'),s++;
if (s>f) vec.push_back('L'),s--;
}
if (s==f) break;
u++;
}

while (s!=f)
{
if (s<f) vec.push_back('R'),s++;
if (s>f) vec.push_back('L'),s--;
}

REP(i,sz(vec)){
cout<<vec[i];
}
cout<<endl;
return 0;
}

-----------------------------

C. Cupboard and Balloons

---

将半径为r/2的圆球放进柜子里。

首先考虑高为h的矩形区域，可证出两两并排向里放圆球最优。

当放满h/r*2个球后，考虑剩下的空间。

有三种可能，放1个，放2个，放3个。。

---

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
int r,h;
int ans=0;
cin>>r>>h;
ans+=h/r*2;
h=h%r;
if (h>=sqrt(3)/2*r) ans+=3;
else if (h>=1.0*r/2) ans+=2;
else ans+=1;
cout<<ans<<endl;
return 0;
}

-----------------------------
D. Xenia and Dominoes

---

问3XN的格子有多少种骨牌摆放方案使其变成一个合理的游戏。

若只考虑摆放方案，不考虑游戏是否合理（即空格是否可以移动），则问题转化成了传统的状态压缩dp。

对于空格的x坐标。若x=1或x=3，可以发现无论骨牌怎样摆放，空格都是可以移动的。

对于x=2。

若空格右侧有空间(y+2<=n)，则将空格右侧横放一个骨牌，再dp求出此时的方案数。

若左侧有空间，则左侧横放骨牌，求出方案数。

若左右都有空间，则将左右各方骨牌，总方案数减去此时的方案数。

得出答案。

---

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>

using namespace std;

const int MAXN=16384;
const int MOD=1000000007;
char s[4][MAXN];
int f[MAXN][8];
int n,sx,sy;

void input(){
cin>>n;
for (int i=1;i<=3;i++){
cin>>(s[i]+1);
}
}
void findDot(){
for (int i=1;i<=3;i++){
for (int j=1;j<=n;j++){
if (s[i][j]=='O'){
sx=i;
sy=j;
return;
}
}
}
}
int getBit(int j){
int res=0;
for (int i=1;i<=3;i++){
if (s[i][j]!='.') res|=(1<<(3-i));
}
return res;
}
int getDP(int i,int k){
if (k==0) return f[i-1][7];// 000 <- 111
if (k==1) return f[i-1][6];// 001 <- 110
if (k==2) return f[i-1][5];// 010 <- 101
if (k==3) return (f[i-1][4]+f[i-1][7])%MOD;// 011 <- 100,111
if (k==4) return f[i-1][3];// 100 <- 011
if (k==5) return f[i-1][2];// 101 <- 010
if (k==6) return (f[i-1][1]+f[i-1][7])%MOD;// 110 <- 001,111
if (k==7) return ((f[i-1][0]+f[i-1][3])%MOD+f[i-1][6])%MOD;// 111 <- 000,011,110
return -1;
}
int solve(){
memset(f,0,sizeof(f));
f[0][7]=1;
for (int i=1;i<=n;i++){
int k=getBit(i);
for (int j=k;j<=7;j++){
if ((j&k)==k){
f[i][j]=getDP(i,j&(~k));
}
}
}
return f
[7];
}

int special(){
int ans=0;
bool lb=false,rb=false;
if (sy-2>=1){
if (s[2][sy-1]=='.'&&s[2][sy-2]=='.'){
s[2][sy-1]=s[2][sy-2]='X';
ans+=solve();
s[2][sy-1]=s[2][sy-2]='.';
lb=true;
}
}
if (sy+2<=n){
if (s[2][sy+1]=='.'&&s[2][sy+2]=='.'){
s[2][sy+1]=s[2][sy+2]='X';
ans+=solve();
s[2][sy+1]=s[2][sy+2]='.';
rb=true;
}
}
if (lb&&rb){
s[2][sy-1]=s[2][sy-2]='X';
s[2][sy+1]=s[2][sy+2]='X';
ans-=solve();
s[2][sy-1]=s[2][sy-2]='.';
s[2][sy+1]=s[2][sy+2]='.';
}
while (ans<0) ans+=MOD;
ans%=MOD;
return ans;
}

int main()
{
input();
findDot();
if (sx==2) cout<<special()<<endl;
else cout<<solve()<<endl;
return 0;
}

-----------------------------
E. Xenia and Tree

---

有一棵n个节点的树，根节点为红色，其它节点没有颜色，给出m个操作。

1 x ：将节点x染成红色

2 x ：输出节点x的距红色节点的最短距离

平方分割法。令block=sqrt(m)。

对于操作1，将待染色节点其加入队列que

对于操作2，若队列元素个数>block，则利用队列里的红色节点做一次bfs，更新所有点到红色节点的最短距离。并输出dis[x]；

若元素个数不足block，则将dis[x]与点x到队列里所有的元素的距离做比较，并输出。

求树上两点间的最短距离，用LCA实现。

---

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <queue>
#include <stack>
#include <cmath>
using namespace std;
const int maxn=211111;
const int maxm=611111;
const int INF=0x3f3f3f;
//------最短路----------
struct EdgeNode{
int to;
int next;
};
EdgeNode edges[maxm];
int head[maxn],edge,n;
void addedge(int u,int v){
edges[edge].to=v,edges[edge].next=head[u],head[u]=edge++;
}
void init(){
memset(head,-1,sizeof(head));
edge=0;
}

//---------MAIN---------------
bool vis[maxn];
int dis[maxn];
queue<int>que;
int block;
void dfs(int u,int pa){
if (pa==0) dis[u]=0;
else dis[u]=dis[pa]+1;
for (int i=head[u];i!=-1;i=edges[i].next){
int v=edges[i].to;
if (v!=pa) dfs(v,u);
}
}
void bfs(){
memset(vis,0,sizeof(vis));
while (!que.empty()){
int u=que.front();
que.pop();
for (int i=head[u];i!=-1;i=edges[i].next){
int v=edges[i].to;
if (dis[u]+1<dis[v]){
dis[v]=dis[u]+1;
if (!vis[v]){
que.push(v);
vis[v]=true;
}
}
}
}
}
//-----RMQ--------------
int d[maxn][30];
//元素从1编号到n
void makeRmqIndex(int A[],int n){
for(int i=1;i<=n;i++) d[i][0]=i;
for(int j=1;(1<<j)<=n;j++)
for(int i=1;i+(1<<j)-1<=n;i++)
d[i][j] = A[d[i][j-1]] < A[d[i+(1<<(j-1))][j-1]]? d[i][j-1]:d[i+(1<<(j-1))][j-1];
}
int rmqIndex(int L,int R,int A[]){
int k=0;
while ((1<<(k+1))<=R-L+1) k++;
return A[d[L][k]]<A[d[R-(1<<k)+1][k]]? d[L][k]:d[R-(1<<k)+1][k];
}
//------LCA------------------------
int deep[maxn];
int E[maxn*2],R[maxn],D[maxn*2],mn;
void dfs(int u,int p,int d){
E[++mn]=u;
D[mn]=d;
R[u]=mn;
for (int i=head[u];i!=-1;i=edges[i].next){
int v=edges[i].to;
if (v==p) continue;
dfs(v,u,d+1);
E[++mn]=u;
D[mn]=d;
}
}
void getd(int u,int p,int w){
deep[u]=w;
for (int i=head[u];i!=-1;i=edges[i].next){
int v=edges[i].to;
if (v==p) continue;
getd(v,u,w+1);
}
}
void LCA_init(){
mn=0;
memset(R,0,sizeof(R));
dfs(1,-1,1);
makeRmqIndex(D,mn);
getd(1,-1,0);
}
int LCA(int u,int v){
if (R[u]>=R[v]) return E[rmqIndex(R[v],R[u],D)];
else return E[rmqIndex(R[u],R[v],D)];
}
int getDis(int u,int v){
int lca=LCA(u,v);
return deep[u]+deep[v]-deep[lca]*2;
}

int main()
{
int m;
int x,y;
scanf("%d%d",&n,&m);
init();
block=sqrt(m);
for (int i=1;i<n;i++){
scanf("%d%d",&x,&y);
addedge(x,y);
addedge(y,x);
}
dfs(1,0);
LCA_init();
for (int i=1;i<=m;i++){
int x,y;
scanf("%d%d",&x,&y);
if (x==1){
que.push(y);
dis[y]=0;
}
else if (x==2){
if ((int)que.size()>block){
bfs();
printf("%d\n",dis[y]);
}
else{
int ans=dis[y];
int bg=0;
while (!que.empty()){
int q=que.front();
if (bg==0) bg=q;
else if (bg==q) break;
que.pop();
ans=min(ans, getDis(y,q) );
que.push(q);
}
printf("%d\n",ans);
}
}
}
return 0;
}

-----------------------------

---

---