NENU ACM 13级训练赛 2014-12-06(福州大学第十一届程序设计竞赛)

福大的校赛，题目是中文的，省去了大家读题的时间。

A题：水题

每7天就有一个周六和周日，算一算就行了。

<span style="font-size:18px;">#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdio>
using namespace std;

int main(){
int n;
while(~scanf("%d",&n)){
int num = n/7;
int left = n%7;
int ans = num*2;
if(left == 6) ans++;
printf("%d\n",ans);
}
return 0;
}</span>

B题：规律

类似单调队列，其实就是个O(n)的递推水题，把样例推一推就清楚了

2 1 3 1 4

2*1 + 1*2 + 3*3 (1)

1*1 + 3*2 + 1*3 (2)

3*1 + 1*2 + 4*3 (3)

式子(1)为 13

式子(2)为 13 - 2*1 - (1+3) + 1*3 = 10

即： 13 - (2+1+3) + 1*3 = 10

式子(3)为 10 - 1*1 - (3+1) + 4*3 = 17

即： 10 - (1+3+1) + 4*3 = 17

可以发现，式子(i)式子(i-1)减去sum(x[i-m]~x[i])再加上新的项。

这样扫一遍取最大就可以了

<span style="font-size:18px;">#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>

using namespace std;

const int MAXN = 1000010;
int a[MAXN];
int sum[MAXN];
int n,m;

int main() {
while(~scanf("%d%d",&n,&m)) {
sum[0] = 0;
for(int i=1; i<=n; i++) {
scanf("%d",&a[i]);
sum[i] = sum[i-1] + a[i];
}
int ans = -1;
int tmp = 0;
for(int i=1; i<=m; i++) {
tmp += i*a[i];
}
ans = max(ans,tmp);
for(int i=m+1; i<=n; i++) {
tmp = tmp - (sum[i-1]-sum[i-m-1]) + m*a[i];
ans = max(tmp,ans);
}
printf("%d\n",ans);
}
return 0;
}</span>

C题：DFS

由题可知，给出的图是一颗树。

设1为根，我们都知道对于树，若一条边只能走一次，则从根到各个节点的路径是唯一的，而且是最短的。

用邻接表建图，从根开始深搜进去，遍历每一个节点，在回溯的过程中如果是军队要走的路径，就把节点标记一下。

最后把这些被标记的结点上的敌人求个和，就是答案。

<span style="font-size:18px;">#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>

#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;

const int M = 100100;

bool vis[M];
int val[M];

struct G{
struct E{
int v,next;
}e[M<<1];
int le,head[M];
void init(){
le=0;
mt(head,-1);
}
void add(int u,int v){
e[le].v=v;
e[le].next=head[u];
head[u]=le++;
}
}g;

int fa[M];
void dfs(int u){
for(int i=g.head[u];~i;i=g.e[i].next){
int v = g.e[i].v;
if(fa[u]==v) continue;
fa[v] = u;
dfs(v);
if(vis[v]){
vis[u]=true;
}
}
}

int main(){
int n,k;
while(~scanf("%d%d",&n,&k)){

mt(vis,false);
mt(fa,-1);

g.init();
for(int i=1;i<=n;i++){
scanf("%d",&val[i]);
}
int tmp;
for(int i=1;i<=k;i++){
scanf("%d",&tmp);
vis[tmp] = true;
}
int x,y;
for(int i=1;i<n;i++){
scanf("%d%d",&x,&y);
g.add(x,y);
g.add(y,x);
}

dfs(1);

int sum = 0;
for(int i=1;i<=n;i++){
if(vis[i]){
sum += val[i];
}
}
printf("%d\n",sum);
}
return 0;
}</span>

D：DP

动态规划的重点就是定义出状态，已经状态的变化，据此写出状态转移方程之后，问题就迎刃而解了。

定义dp[i][j]表示到第i位时，有j位属于第一个串。

那么对于第i位的放法，就有放在第一个串和不放在第一个串这两种选择，然后更新数组，推到下一个状态。

注意推的过程中要模mod

为了节省空间，我采用了滚动数组，大概不用滚动数组也是能AC的，可以试试。

对于这个题目转移思想和滚动数组的使用，建议认真研究一下《背包九讲》

#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdio>

#define LL __int64
#define mt(a,b) memset(a,b,sizeof(a))

using namespace std;

const LL MOD = 1e9+7;
const int M = 3010;

char str[M];
LL dp[2][M];

int n;

int main() {
int _;
scanf("%d",&_);
while(_--) {
scanf("%d",&n);
scanf("%s",str);
mt(dp,0);
dp[0][0] = 1;
int now = 1;
for(int i=0; i<2*n; i++) {
mt(dp[now&1],0);
if (str[i]=='B') {
for (int j=0; j<=n; j++) {
//奇数
if (j&1)  {
dp[now&1][j+1] = (dp[now&1][j+1] + dp[i&1][j]) % MOD;

}
if ((i-j)&1) {
dp[now&1][j] = (dp[now&1][j] + dp[i&1][j]) % MOD;
}
}
} else {
for (int j=0; j<=n; j++) {
if ((j&1) == 0) {
dp[now&1][j+1] = (dp[now&1][j+1] + dp[i&1][j]) % MOD;
}
if (((i-j)&1) == 0) {
dp[now&1][j] = (dp[now&1][j] + dp[i&1][j]) % MOD;
}
}
}
now++;
}
printf("%I64d\n",dp[0]
);
}
return 0;
}

E：线段树

很明显的线段树的题，采用lazy数组延迟标记，区间查询区间更新。

属于基础题，望多加巩固练习。

题目说有30%的小数据，可能暴力能过吧，我不清楚，我看见有人裸暴TLE，还是稳一点吧。

#include<cstdio>
#define lrrt int L,int R,int rt
#define iall 1,n,1
#define imid int mid=(L+R)>>1
#define lson L,mid,rt<<1
#define rson mid+1,R,rt<<1|1
const int M=1e5+10;
int a[M];
struct T {
int sum,lazy;
} tree[M<<2];
void pushup(int rt) {
tree[rt].sum=tree[rt<<1].sum+tree[rt<<1|1].sum;
}
void build(lrrt) {
tree[rt].lazy=0;
if(L==R) {
tree[rt].sum=a[L];
return ;
}
imid;
build(lson);
build(rson);
pushup(rt);
}
void pushdown(int mid,lrrt) {
if(tree[rt].lazy) {
tree[rt<<1].lazy+=tree[rt].lazy;
tree[rt<<1|1].lazy+=tree[rt].lazy;
tree[rt<<1].sum+=(mid-L+1)*tree[rt].lazy;
tree[rt<<1|1].sum+=(R-mid)*tree[rt].lazy;
tree[rt].lazy=0;
}
}
int query(int x,int y,lrrt) {
if(x<=L&&R<=y) return tree[rt].sum;
imid;
pushdown(mid,L,R,rt);
int ans=0;
if(mid>=x) ans+=query(x,y,lson);
if(mid<y)  ans+=query(x,y,rson);
return ans;
}
void update(int x,int y,int z,lrrt) {
if(x<=L&&R<=y) {
tree[rt].sum+=(R-L+1)*z;
tree[rt].lazy+=z;
return ;
}
imid;
pushdown(mid,L,R,rt);
if(mid>=x) update(x,y,z,lson);
if(mid<y)  update(x,y,z,rson);
pushup(rt);
}
int main() {
int n,m,q,x;
while(~scanf("%d%d%d",&n,&m,&q)) {
for(int i=1; i<=n; i++) {
scanf("%d",&a[i]);
}
build(iall);
while(q--) {
scanf("%d",&x);
printf("%d\n",query(x,x+m-1,iall));
update(x,x+m-1,-1,iall);
}
}
return 0;
}

F题：待更新

G题：多源最短路+矩阵快速幂

题目要求从1点到n点的恰好k次最短路

可以很快想到floyd求出各个点之间的最短路，但是k很大，不能递推过去。

可以先求出1秒之后，各个点之间的最短路，得出一个矩阵，然后我们可以用这个矩阵继续推下去，推k-1次，这样就可以想到用矩阵快速幂了。

其实在这里，矩阵快速幂起到了加速的效果。

注意本题的矩阵快速幂并不是常规的矩阵快速幂，需要改写一下，具体看代码。

<span style="font-size:18px;">#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>

#define LL __int64
#define mt(a,b) memset(a,b,sizeof(a))

using namespace std;

const LL inf = 0x3f3f3f3f3f3f3f3fLL;

class Matrix {
typedef LL typev;
static const int MV=55;
friend Matrix operator *(const Matrix &a,const Matrix &b) {
Matrix ret;
ret.n=a.n;
for(int i=0; i<a.n; i++) {
for(int j=0; j<b.n; j++) {
LL tmp = inf;
for(int k=0; k<a.n; k++) {
tmp = min(tmp, a.val[i][k] + b.val[k][j]);
}
ret.val[i][j]=tmp;
}
}
return ret;
}
friend Matrix operator ^ (Matrix a,LL b) {
Matrix ret = a;
while(b) {
if(b&1) ret = a*ret;
a = a*a;
b>>=1;
}
return ret;
}
public:
int n,m;///n行m列
typev val[MV][MV];
void init(int tn) {
mt(val,inf);
n = tn;
}
} A;

int main() {
int n,h;
LL k;
int _;
scanf("%d",&_);
while(_--) {
scanf("%d%d%I64d",&n,&h,&k);
A.init(n);

int u,v;
LL w;
while(h--) {
scanf("%d%d%I64d",&u,&v,&w);
u--;
v--;
A.val[u][v] = min(A.val[u][v],w);
}

Matrix ans = A^(k-1);

if(ans.val[0][n-1] == inf) puts("-1");
else printf("%I64d\n",ans.val[0][n-1]);

}
return 0;
}
</span>

H题：待更新