2012 Multi-University Training Contest 6[hdu4350~4359]
4351 Digital root
4355 Party All the Time
两种解法， 一种三分，一种dp
三分是要满足凹凸性的， 既二阶导数不变号， 这个很好证明的，
题目要求的是sigma|p-xi|^3*wi, 不妨对每项拆开讨论 :
|p-xi|^3*wi ,当p>=xi时 原式为(p-xi)^3*wi 二阶导为(6p-6xi)*wi,恒大于等于0， p<xi同理， 故为凸函数， 由于凸函数加凸函数 还是凸函数， 三分显然是正确的。
dp的话， 就是预处理， 求每一点是直接求出，没有转移，然后求任意点之间的， 直接解2次方程就好， 这个好久没写过类似代码了， 出了好多错， 最后还输出-0wa了2次
using namespace std;
const int mod=1000000007;
const int maxn=50000+123;
double x[maxn], w[maxn];
double l[4][maxn], r[4][maxn];
double dp[maxn];
double sum(int i, double xi)
{
double res=0.0;
res+=xi*xi*xi*l[0][i]-3*xi*xi*l[1][i]+3*xi*l[2][i]-l[3][i];
res+=r[3][i+1]-3*xi*r[2][i+1]+3*xi*xi*r[1][i+1]-xi*xi*xi*r[0][i+1];
return res;
}
double getmin(int i, int j)
{
double a=l[0][i]-r[0][j], b=-3.0*(l[1][i]-r[1][j]), c=3.0*(l[2][i]-r[2][j]);
a*=3., b*=2.;
double delta=b*b-4.0*a*c;
double res=min(dp[i], dp[j]);/// ¶Ëµã
if(zero(a))
{
if(!zero(b))
{
double x1=-c/b;
if(x1>=x[i] && x1<=x[j])res=min(res, sum(i, x1));
//printf("%lf a==0 b!=0 %lf\n", x1, res);
}
}else
if(delta>0)
{
double x1=(-b+(sqrt(delta)))/(2.0*a);
double x2=(-b-(sqrt(delta)))/(2.0*a);
if(x1<=x[j] && x1>=x[i])res=min(res, sum(i, x1));
if(x2<=x[j] && x2>=x[i])res=min(res, sum(i, x2));
///printf("%lf a!=0 %lf\n", x1, sum(i, x1));
}
//printf("res=%lf\n", res);
return res;
}
int main ()
{
///freopen("1006.in", "r", stdin);
int cas; scanf("%d", &cas);
for (int I=1; I<=cas; ++I)
{
int n; scanf("%d", &n);
for (int i=0; i<n; ++i) scanf("%lf%lf", x+i, w+i);
clean(l, 0); clean(r, 0);
for (int i=0; i<n; ++i)
{
double tmp=w[i];
for (int j=0; j<4; ++j)
{
if(i)l[j][i]=l[j][i-1];
l[j][i]+=tmp;
tmp*=x[i];
}
}
for (int i=n-1; i>=0; --i)
{
double tmp=w[i];
for (int j=0; j<4; ++j)
{
r[j][i]=r[j][i+1]+tmp;
tmp*=x[i];
}
}
double ans=infll*10.0;
for (int i=0; i<n; ++i)
{
dp[i]=sum(i, x[i]);
///printf("%lf\n", dp[i]);
ans=min(ans, dp[i]);
}
for (int i=0; i<n-1; ++i)
{
ans=min(ans,getmin(i, i+1));
}
printf("Case #%d: %.0lf\n", I, ans+eps);///不加eps会输出-0, 囧
}
return 0;
}
4358 Boring counting
1.启发式合并 其实就是暴力， 但是在合并时选择从小的合并到大的里， 直接dfs一遍统计出所有的节点的答案， 然后o（1）查询即可， 不过可能是我dfs写的垃圾了， 标程在本地跑暴栈， 交到hdu上ac，我在本地跑暴栈， 交上去还是暴栈， 果断改成手工栈， ToT
2. 将树形结构转成线性结构， 对子树的查询就变为对点的查询。
#include <stdio.h>
#include <string.h>
#include <map>
#include <stack>
#include <algorithm>
#define fst first
#define scd second
#define clean(a, x) memset (a, x, sizeof(a));
#define copy(a, b) memcpy(a, b, sizeof(a));
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int maxn=100000+10;
#define vex edge[p].v
int w[maxn];
struct Edge{int v, next;}edge[2*maxn];
int head[maxn], cnt;
void addedge(int u, int v){edge[cnt].v=v; edge[cnt].next=head[u]; head[u]=cnt++;}
///*** graphic theory***///
int f[maxn], ans[maxn];
map <int , int> node[maxn];
map<int , int>:: iterator it, pp;
int n, k;
void merge(int a, int b)
{
int sa=node[f[a]].size(), sb=node[f[b]].size();
// printf("v==%d u=%d\n", a, b);
if(sa>sb)
{
ans[b]+=ans[a];
for (it=node[f[b]].begin(); it!=node[f[b]].end(); ++it)
{
pp=node[f[a]].find(it->fst);
if(pp!=node[f[a]].end())
{
if(pp->scd==k)ans[b]--;
if(it->scd==k)ans[b]--;
pp->scd+=it->scd;
if(pp->scd==k)ans[b]++;
}
else
{/// not exist
node[f[a]][it->fst]=it->scd;
///if(it->scd==k)ans[b]++;
}
}
node[f[b]].clear();
f[b]=f[a];
}
else
{
for (it=node[f[a]].begin(); it!=node[f[a]].end(); ++it)
{
pp=node[f[b]].find(it->fst);
if(pp!=node[f[b]].end())
{
if(pp->scd==k)ans[b]--;
pp->scd+=it->scd;
if(pp->scd==k)ans[b]++;
}
else
{
node[f[b]][it->fst]=it->scd;
if(it->scd==k)ans[b]++;
}
}
node[f[a]].clear();
}
}
//void dfs(int u, int fa)
//{
// node[f[u]][w[u]]=1;
// if(k==1)ans[u]++;
// for (int p=head[u]; ~p; p=edge[p].next)
// {
// if(vex==fa)continue;
// dfs(vex, u);
// merge(vex, u);
// }
//}
stack<int> S;
bool vis[maxn];
int rec[maxn], pre[maxn];
void DFS()
{
int u, v, p;
S.push(1);
node[f[1]][w[1]]=1;
if(k==1)ans[1]++;
pre[1]=-1;
copy(rec, head);
while (!S.empty())
{
u=S.top();
vis[u]=true;
bool flag=false;
for (p=rec[u]; ~p; p=edge[p].next)
{
if(vis[vex])continue;
S.push(vex);
node[f[vex]][w[vex]]=1; if(k==1)ans[vex]++;
pre[vex]=u;
rec[u]=edge[p].next;
flag=true;
break;
}
if(flag)continue;
if(~pre[u])
{
merge(u, pre[u]);
}
S.pop();
// if(p==-1)
// {
// for (p=rec[u]; ~p; p=edge[p].next)
// {
// if(vis[vex])continue;
// merge(u, vex);
// }
// S.pop();
// }
}
}
void init()
{
clean(head, -1); cnt=0; clean(ans, 0);
clean(vis, false);
for (int i=1; i<=n; ++i) f[i]=i;
for (int i=1; i<=n; ++i) node[i].clear();
}
int main()
{
// freopen("1009.in", "r", stdin);
// freopen("1009a.out", "w", stdout);
int cas; scanf("%d", &cas);
for (int I=1; I<=cas; ++I)
{
scanf("%d%d", &n, &k);
for (int i=1; i<=n; ++i) scanf("%d", w+i);
init();
for (int i=1; i<n; ++i)
{
int u, v; scanf("%d%d", &u, &v);
addedge(u, v); addedge(v, u);
}
// dfs(1, -1);
DFS();
if(I>1)puts("");
printf("Case #%d:\n", I);
int Q; scanf("%d", &Q);
while (Q--)
{
int q; scanf("%d", &q);
printf("%d\n", ans[q]);
}
}
return 0;
}
/*
4
4 2
1 2 2 3
1 2
1 3
3 4
4
4
2
1
3
4 1
1 2 2 3
1 2
1 3
3 4
4
4
2
1
3
3 1
1 2 2
1 2
1 3
3
2
1
3
3 2
1 2 2
1 2
1 3
3
2
1
3
*/
hdu 4359 一道很简单的dp就因为维护前缀和的时候只维护到了最后一个有值的点， 下午比赛卡了2小时， 都没心情做其他题了。
还是和很多2叉树计数一样， 2个状态节点数，和高度。 这里有个前缀和的优化， 一定要注意前缀和的处理！
using namespace std;
const int mod=1000000007;
ll com[400][400];
ll dp[400][400];
ll sum[400][400];
bool can(int ns, int h)
{
if(h>8)return ns>=h;
return (1<<h)-1 >= ns && ns>=h;
}
void init()
{
clean(com, 0);
com[0][0]=1;
com[1][0]=1; com[1][1]=1;
for(int i=2; i<400; ++i)
{
com[i][0]=1;
for (int j=1; j<=i; ++j)
com[i][j]=(com[i-1][j]+com[i-1][j-1])%mod;
}
}
const int maxn=380;
int main ()
{
init();
clean(dp, 0);
clean(sum, 0);
dp[0][0]=1; dp[1][1]=1; dp[1][0]=0;
sum[0][0]=1; sum[1][1]=1;
for (int i=1; i<=maxn; ++i)sum[0][i]=sum[1][i]=1;///!!!!!
int cas; scanf("%d", &cas);
for (int i=2; i<=maxn; ++i)
{
for (int j=2; j<=maxn; ++j)
{
sum[i][j]=sum[i][j-1];
if(!can(i, j))continue;
ll res=0;
if(can(i-1, j-1))res+=dp[0][0]*dp[i-1][j-1]%mod*2%mod;
for (int k=j-1; k+1<i; ++k)
{
res+=((dp[k][j-1]*sum[i-k-1][j-1])%mod*(com[i-2][k]))%mod;
res+=((dp[k][j-1]*sum[i-k-1][j-2])%mod*(com[i-2][i-k-1]))%mod;
//res+=((dp[k][j-1]*dp[i-k-1][j-1])%mod*(com[i-2][k]))%mod;
res%=mod;
}
dp[i][j]=res*i%mod;
///if(dp[i][j]<0)printf("%d %d\n", dp[][])
sum[i][j]=(sum[i][j-1]+dp[i][j])%mod;
}
}
for (int I=1; I<=cas; ++I)
{
int a, b; scanf("%d%d", &a, &b);
printf("Case #%d: %I64d\n", I, dp[a][b]%mod);
}
return 0;
}
/*
10
3 2
1 1
2 2
4 3
5 4
6 3
360 360
5 5
7 4
*/