C++博客-From A Start,As An Acmer-随笔分类-BOJ Solution Report

HDU 4087 & BOJ 244 A Letter to Programmers 【三维仿射变幻的齐次矩阵乘+快速幂】

BUPT-[aswmtjdsj] @ Penalty — Mon, 07 Nov 2011 11:55:00 GMT

题意很裸，亮点在于将齐次仿射变换矩阵和快速幂结合起来。

题目读入延续了pku出题的ws风格，还得用一个dfs处理读入。
题目输出也很蛋疼，标准写法竟然会导致-0.0出现，必须手动加一个eps来修改偏差。没有spj的二货。

附上仿射变换矩阵：

平移

translate tx ty tz

1 0 0 tx

0 1 0 ty

0 0 1 tz

0 0 0 1

缩放

scale kx ky kz

kx 0 0 0

0 ky 0 0

0 0 kz 0

0 0 0 1

绕任意轴（过原点）旋转（注意要把轴向量归一化，不然会在“点在轴上”这个情况下出问题）

rotate x y z d

(1-cos(d))*x*x+cos(d) (1-cos(d))*x*y-sin(d)*z (1-cos(d))*x*z+sin(d)*y 0

(1-cos(d))*y*x+sin(d)*z (1-cos(d))*y*y+cos(d) (1-cos(d))*y*z-sin(d)*x 0

(1-cos(d))*z*x-sin(d)*y (1-cos(d))*z*y+sin(d)*x (1-cos(d))*z*z+cos(d) 0

0 0 0 1

附代码，一开始装b用stack模拟读入过程，re啊wa啊各种sb。最后被迫用了dfs。唉，naive。

#include
#include
#include
#include
#include
#include
using namespace std;
const double eps = 1e-6;
const double pi = acos(-1.0);
const int maxn = 1005;
int sgn(double x){return x < -eps?-1:x > eps;}
#define rep(i,j,k) for(int (i) = (j);(i) < (k);(i) ++)
struct matrix
{
    int r,c;
    double v[5][5];
    matrix(){}
    matrix(int a,int b):r(a),c(b)
    {
        rep(i,0,r)
            fill(v[i],v[i] + c,0.0);
        if(r == c)
        {
            rep(i,0,r)
                v[i][i] = 1.0;
        }
    }
    matrix init()
    {
        return matrix(r,c);
    }
    matrix operator * (const matrix p)
    {
        matrix ans(r,p.c);
        rep(i,0,r)
            rep(j,0,ans.c)
            {
                double tmp = 0.0;
                rep(k,0,c)
                    tmp += v[i][k] * p.v[k][j];
                ans.v[i][j] = tmp;
            }
        return ans;
    }
};
matrix power(matrix a,int n)
{
    matrix e(a.c,a.c);//square matrix of a.c * a.c
    if(n == 0)
        return e;
    matrix ans = power(a,n/2);
    ans = ans * ans;
    return (n%2)?ans * a : ans;
}
struct point
{
    double x,y,z;
    point(){}
    point(double a,double b,double c):x(a),y(b),z(c){}
    void in()
    {
        scanf("%lf %lf %lf",&x,&y,&z);
    }
    void print()
    {
        printf("%.2lf %.2lf %.2lf\n",x + eps,y + eps,z + eps);
    }
}p[maxn];
int n;
point fuck(point now,matrix a)
{
    matrix o(4,1);
    o.v[0][0] = now.x;
    o.v[1][0] = now.y;
    o.v[2][0] = now.z;
    o.v[3][0] = 1.0;
    matrix ans = a * o;
    return point(ans.v[0][0],ans.v[1][0],ans.v[2][0]);
}
char op[20];
matrix dfs(int times)
{
    matrix ans(4,4);
    double v[5];
    int what;
    while(scanf("%s",op) == 1)
    {
        matrix temp(4,4);
        if(op[0] == 'e')
            break;
        else if(op[0] == 'r')
        {
            if(op[1] == 'e')
            {
                scanf("%d",&what);
                temp = dfs(what);
            }
            else
            {
                rep(i,0,4)
                    scanf("%lf",&v[i]);
                double l = 0.0;
                rep(i,0,3)
                    l += v[i] * v[i];
                l = sqrt(l);
                v[3] = v[3] / 180.0 * pi;
                double ct = cos(v[3]),st = sin(v[3]);
                rep(i,0,3)
                    v[i] /= l;
                temp.v[0][0] = (1.0 - ct) * v[0] * v[0] + ct;
                temp.v[0][1] = (1.0 - ct) * v[0] * v[1] - st * v[2];
                temp.v[0][2] = (1.0 - ct) * v[0] * v[2] + st * v[1];
                temp.v[1][0] = (1.0 - ct) * v[1] * v[0] + st * v[2];
                temp.v[1][1] = (1.0 - ct) * v[1] * v[1] + ct;
                temp.v[1][2] = (1.0 - ct) * v[1] * v[2] - st * v[0];
                temp.v[2][0] = (1.0 - ct) * v[2] * v[0] - st * v[1];
                temp.v[2][1] = (1.0 - ct) * v[2] * v[1] + st * v[0];
                temp.v[2][2] = (1.0 - ct) * v[2] * v[2] + ct;
            }
        }
        else if(op[0] == 't')
        {
            rep(i,0,3)
            {
                scanf("%lf",&v[i]);
                temp.v[i][3] = v[i];
            }
        }
        else if(op[0] == 's')
        {
            rep(i,0,3)
            {
                scanf("%lf",&v[i]);
                temp.v[i][i] = v[i];
            }
        }
        ans = temp * ans;
    }
    return power(ans,times);
}
int main()
{
    while(scanf("%d",&n) == 1 && n)
    {
        matrix temp(4,4);
        temp = dfs(1) * temp;
        for(int i = 0;i < n;i++)
        {
            p[i].in();
            p[i] = fuck(p[i],temp);
            p[i].print();
        }
        puts("");
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-11-07 19:55 发表评论

BOJ 247 Gem And Prince ［剪枝爆搜］［36th ACM/ICPC Beijing Regional Onsite J］

BUPT-[aswmtjdsj] @ Penalty — Wed, 26 Oct 2011 06:06:00 GMT

这题我出的，因为邀请赛时候出了道题意有点问题的模板题，所以这次决定出一道题意清楚的非模板题。
那天躺在床上玩ipad，突然玩到了《终极宝石》，于是乎就动了给这个游戏写外挂的想法，也就变成了一道题，本来是想出给网赛的，但谁知道最后变成了现场赛题目。

judge们看了现场赛最后的题目之后，给这题定为的是第三题，结果由于题目太长＋水题太坑＋神队带歪了board，这题最后也没几个人过。。。
其实就是一道搜索而已，而且数据很小，时限很松，随手加点剪枝就可以过。

这题明显不存在局部最优解，所以我们想到的解题方法是模拟+搜索+剪枝。

模拟+搜索：对于每一个局面，用bfs穷举出下一步所有可能存在的消除宝石的方法，每发现这样的一个方法就dfs进入下一层。

（即通过floodfill的方法进行bfs，每得到一个大小大于2的连通块的时候就dfs递归深入下去。这样可以让下面的剪枝得到很好的效果，可以将搜索树的size大大减小。）

剪枝：对于每一个局面，记录它通过之前的步骤已经得到的分数，然后维护它还可能得到的最大的分数（比如已经得到了120分，还有5个红色宝石，4个蓝色宝石，2个黑色宝石，那此局面可能得到的分数一定不超过120+5*5+4*4），通过用这个分数与当前已经得到的最大分数进行比较来进行剪枝。对于大多数数据这个剪枝能剪掉99.9%的节点，所以有时可以跑过10*9的数据，但是这个剪枝也是不稳定的，存在不少数据能把它卡掉。不过对于题目的最大上限8*8，这个剪枝已经足够了。

至于整体的复杂性分析等我有空或者哪位大牛有空可以详细写一下，在这里就不写出了。
我在当judge的时候看到最快的做法是除了以上剪枝之外，还把当前局面hash掉，每次判一下hash，虽然常数会稍微增大，但是重复状态会减少很多。没准加了hash之后可以跑过原来游戏中12*12的解也未可知呢。

话说自己写的标被挂掉了，因为常数太大。。。我在这里就放出我的小队友claire大神的标吧。等我有空也许会去写一份加上神优化hash的标呢。

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

using namespace std;
const int N=14;
int a[N][N],v[N][N],t[N];
int d[8][2]={-1,-1,-1,0,-1,1,0,-1,0,1,1,-1,1,0,1,1};
int m,n,o,ans;

int  bfs(int p,int q,int a[][N],int id[][N],int w)
{

    int f[N*N][2];
    int i,l=1,r=1,x,y;
    f[1][0]=p; f[1][1]=q;
    v[p][q]=1;
    while (l<=r)
    {
        p=f[l][0]; q=f[l][1];
        id[p][q]=w;
        for (i=0; i<8; i++)
         {
             x=p+d[i][0];
             y=q+d[i][1];
             if (x>=1 && x<=m && y>=1 && y<=n && a[x][y]==a[p][q] && v[x][y]==0)
              {
                  r++; v[x][y]=1;
                  f[r][0]=x; f[r][1]=y;
              }
         }
        l++;
    }
    return r;
}

void change(int b[][N])
{
     int temp1[N],temp2[N],i,j,x,y,s=0;
     for (j=1; j<=n; j++)
      {
          x=0; y=m;
          for (i=1; i<=m; i++)
           if (b[i][j]>0) temp1[++x]=i;
          if (x>0) temp2[++s]=j;
          while (x>0)
          {
              if (y!=temp1[x]){ b[y][j]=b[temp1[x]][j]; b[temp1[x]][j]=0;}
              x--;
              y--;
          }
      }
     x=1; y=1;
     while (x<=s)
     {
         if (y!=temp2[x]) for (i=1; i<=m; i++) {b[i][y]=b[i][temp2[x]]; b[i][temp2[x]]=0;}
         x++;
         y++;
     }
}

void dfs(int s,int a[][N],int sum)
{
    if (s>ans) ans=s;
    int c[N*N],e[N*N],id[N][N]={0},w=0;
    memset(v,0,sizeof(v));
    for (int i=1; i<=m; i++)
      for (int j=1; j<=n; j++)
        if (a[i][j]>0 && t[a[i][j]]>=3 && v[i][j]==0 )
        {
            w++;
            c[w]=bfs(i,j,a,id,w);
            e[w]=a[i][j];
        }
    int b[N][N];
    for (int k=1; k<=w; k++)
      if (c[k]>=3)
      {
              int sum1=sum-t[e[k]]*t[e[k]];
              if (t[e[k]]-c[k]>=3)  sum1=sum1+(t[e[k]]-c[k])*(t[e[k]]-c[k]);
              if (sum1+s+c[k]*c[k]>ans)
              {
                for (int i=1; i<=m; i++)
                 for (int j=1; j<=n; j++)
                  if (id[i][j]==k)
                    b[i][j]=0; else b[i][j]=a[i][j];
                change(b);
                t[e[k]]-=c[k];
                dfs(s+c[k]*c[k],b,sum1);
                t[e[k]]+=c[k];
              }
      }
}

int main()
{
    int i,j,k;
    while (scanf("%d%d%d",&m,&n,&o)==3)
    {
        int sum=0;
        memset(t,0,sizeof(t));
        for (i=1; i<=m; i++)
          for (j=1; j<=n; j++)
           {
               scanf("%d",&a[i][j]);
               t[a[i][j]]++;
           }
        for (int i=1; i<=o; i++)
          if (t[i]>=3) sum+=t[i]*t[i];
        ans=0;
        dfs(0,a,sum);
        printf("%d\n",ans);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-10-26 14:06 发表评论

36th ACM/ICPC 北京网赛memo＋一句话解题报告

BUPT-[aswmtjdsj] @ Penalty — Sun, 18 Sep 2011 14:16:00 GMT

Beijing Online Memo & Solution Report(Approximate)
这份memo我记录的，就发一下吧。本场的所有题都不是我出的，所以我就不发详细解题报告了，只发个一句话版。

Memo
现在是11:57分开始记录
题目排版全是乱的，我们的排版明明是正确的。。但是却发现后台看和前台看是不一样的。
伤不起。。
哪里去了！！！！
12:01 第一个提交WA return 0
12:07 三个提交A题这道题怎么可能能过呢。。。
12:16 G题被搞，by 中山
12:17 D题被搞，by SJTU
12:19 六大强校就是六大强校，现在过题的三队中山、sjtu、sjtu
12:21 sjtu搞了B题
12:24 Tsinghua 搞了F题
12:26 J题被搞 by ZJUT
12:32 sjtu两题！！还是两支队伍
12:36 fdu贡献了第一个PE
12:48 K题终于可以提问了- -某个神奇的bug。。。
12:49 浙大的gao队 3题
12:51 ECNU也三题了！（43,49,50）太虎了。。登顶。。。
12:52 E题有人过了 Tsinghua
12:57 ZJU 4 题，各种反超问鼎。。
13:02 K题被过，by FUDAN
13:12 fudan 五题
13:13 MLE的fb出现
13:29 fudan 6题
13:52 吐个槽。。。真心伤不起。。。oj的各种bug。。。
13:53 fudan7题，V5
14:23 三队七题。。这board有点像后期的board。。各种bug伤不起啊。。。。
14:31 I题FB。。。fudan 8题。。这才两个半小时啊。
15:00 hust8题，C题FB。。。。太虎了。。
15:35 SJTU过了H题，大坑竟然1A。orz！！！
15:50 一个0题的HIT的队伍过了A题！！！！！orzzzzzzzzzzz！！！这憋了四个小时终于破了A题的FB。。实现了全场的理论ak。。
16:10 SJTU9题 H竟然1A！！！
16:30 FDU9题！！！竟然用比标程还短的方法把A题过了！！！
16:53 略微吐个槽。。。。。各种999ms 1000ms 2000ms过题。。。伤不起。。。标程真的时间很短；你们真的很能蹭过去。。。
16:57 ECNU用随机算法水过了A题。。这。。。。数据水果然伤不起。。。。
本场算是有惊无险的度过去了，感谢各位大神来踩。

A题模拟+单纯形（数据改小了，HIT的队伍dfs+剪枝剪过去了。。FDU用SAP过了。。。orz。。。。还有被貌似贪心＋rand()的一份神代码水过了）
B题模拟（好像有点小坑？出题人表示都木有想到）
C题三维计算几何（近似算法迭代是不可搞定的，北大的数据还是蛮强的。。。）
D题高精＋数学
E题树形DP＋背包啥的
F题 dp，状态转移显然，注意取模
G题树状数组(MM题)
H题 “水“的计算几何 + 单调队列(hl 大神没过trick啊=.=...一个山峰肿么办?...)
I题数学（AC大神说是水题）
J题状态dp（网络流过的都是神，完虐标程）
K题概率dp （据说读题很坑？出题和验题人表示木有感觉；样例9组数据，标程.out 10组数据，所以过了sample，这题基本就过了）

以上各题都不是我出的哈，不要吐槽本蒟蒻了。拜谢～

BUPT-[aswmtjdsj] @ Penalty 2011-09-18 22:16 发表评论

POJ 1981 Circle and Points 【定长圆覆盖最多点问题】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 05:14:00 GMT

定长圆覆盖最多点问题

问题描述，给出二维平面内N个点的(x,y)坐标，给一固定半径R。求一圆，圆心位置任意，要求尽可能多的覆盖平面点集中的点。输出最多的覆盖点数。

（限制条件，保证无任意两点距离等于2R，即无两点连线恰为直径。亦无任意三点同时在一个半径为R的圆上。）

朴素算法：由限制条件可知，最后目标圆圆心一定可由某两点唯一确定（即目标圆的圆弧上一定恰有两个平面点集中的点）。具体实现：C(N,2)枚举任意两圆，构造可行圆，枚举N个点，判断是否在圆上或者圆内（即是否被覆盖）。复杂度O(N^3)。

（如果过了就算是水过去的吧，没过就怪常数太大。。= =||）

我所知的标准做法：O(n^2*logn)的圆上交点扫描法。

转化为圆上的弧最多被覆盖几次的问题。

直觉可解，圆上某个弧如果被某个圆覆盖过，那么我们把目标圆圆心放在该段弧上时，目标圆一定能把该弧所在圆圆心覆盖（即平面点集中的某点）。

所以，被覆盖次数最多的弧的被覆盖次数即为目标圆（最优）最多能够覆盖的点数。

具体做法：

依旧是C(N,2)枚举任意两点，以BA为例，此时i=1,j=0。

求取BA的极角theta，利用atan2（因变量范围(-pi,pi]）。

为方便极角排序，对于负角要+2pi。

B、A构造的圆交于X1，X4两点，求取X1B与BA的夹角和X4B与AB的夹角（相同）。

Phi ，acos(D/2.0/R)，D=dis(A,B)。

以上可得出两圆交点在当前圆上对于圆心的极角。

为方便极角排序，每个极角均加2pi，使域扩张到[0，4pi]，从而防止了跨0角的出现。

alpha[t].value=theta – phi + 2pi,alpha[t].flag = 1(弧的进入端)

alpha[t+1].value = theta + phi + 2pi,alpha[t+1].flag = false（弧的退出端）。

接下来，对于每个圆上的t（偶数）个极角进行排序，再顺序扫描，动态更新最大值。

for(i,0,t)

if(alpha[i].flag)

sum++

else

sum--

if(sum > ans)

ans = sum

最后输出答案时，输出ans+1即可。（因为要算上弧所在圆自身）

复杂度：O(n *(nlogn + t))=O(n^2*logn)

题目链接：http://poj.org/problem?id=1981
http://boj.me/onlinejudge/showproblem.php?problem_id=1679

#include <iostream>

#include <cstdio>

#include <cmath>

#include <algorithm>

#define Mn 300//平面点集中点数

using namespace std;

const double eps = 1e-9;//精度调高点没跑~

const double pi = acos(-1.0);

#define sqr(x) ((x) * (x))

double R;//定长

struct point

{

    double x,y;

    void read()

    {

       scanf("%lf%lf",&x,&y);

    }

    void print()

    {

       printf("%lf%lf\n",x,y);

    }

    double friend dis(const point &a,const point &b)

    {

       return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));

    }

}p[Mn + 5];

struct alpha

{

    double v;

    bool flag;

    bool friend operator <(const alpha &a,const alpha &b)//排序专用偏序关系

    {

       return a.v < b.v;

    }

}alp[Mn * Mn + 5];//C(N,2)*2的可能交点（可能极角）

void solve(int n)

{

    R = 1.0;//本题内为单位圆

    for(int i = 0;i < n;i++)

       p[i].read();

    int MAX = 0;

    for(int i = 0;i < n;i++)

    {

       int t = 0;

       for(int j = 0;j < n;j++)

       {

           if(i == j)

              continue;

           double theta,phi,D;

           D = dis(p[i],p[j]);

           if(D > 2.0 * R)//距离超界直接秒杀

              continue;

//关键部分

           theta = atan2(p[j].y - p[i].y,p[j].x - p[i].x);

           if(theta < 0)

              theta += 2 * pi;

           phi = acos(D / (2.0 * R));

           alp[t].v = theta - phi + 2 * pi;

           alp[t].flag = true;

           alp[t + 1].v = theta + phi + 2 * pi;

           alp[t + 1].flag = false;

           t += 2;

       }

       sort(alp,alp + t);

       int sum = 0;

       for(int j = 0;j < t;j++)

       {

           if(alp[j].flag)

              sum ++;

           else

              sum --;

           if(sum > MAX)

              MAX = sum;

       }

    }

    printf("%d\n",MAX + 1);

}

int main()

{

    int n;

    while(scanf("%d",&n) == 1 && n)

    {

       solve(n);

    }

}

//欢迎围观，请大神轻拍~~~

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 13:14 发表评论

BOJ 1295 ACM system 【可修改堆】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 05:01:00 GMT

ACM systemLogin and star it!Submit: 283 Accepted:39Time Limit: 3000MS Memory Limit: 65535KDescription
912实验室最近设计了一种能够自动控制进程调度的系统，英文名是Automatic Control Machinery，简称ACM。该系统具有很多优秀的功能，为了方便大家的理解，这里先介绍一下关于进程、进程调度的常识。
1、每个进程需要占用1个或多个单位内存空间，然而令人惊叹的是，在912实验室开发的平台上，一个进程只需要占用1个单位内存！
2、每个进程用三个参量来表示，编号、权值、内存地址(0x00000000~0xFFFFFFFF)。
3、所有的进程都被集中到一个名为“进程池”的地方，ACM系统可以实时的从进程池中选取最高优先级的进程。
4、我们定义进程之间的优先级如下，如果两个进程的权值不同，权值大的优先级高；如果权值相同，编号小的进程优先级高。
现在就要介绍下ACM系统的详细功能了，它总共有4种操作：
1、 Get，返回当前最高优先级的进程信息(编号、权值、内存地址)
2、 Creat ID W ADDRESS，在进程池中创建一个编号为ID，权值为W，地址为ADDRESS的进程
3、 Kill ID，无条件的中止编号为ID的进程
4、 Change ID W，改变编号为ID的进程的权值
由于ACM系统尚在理论研究阶段，所以我们希望热心的你帮忙实现该系统，以具备上述所说的功能。当然，你的系统应该有一定的健壮性，至少能够对错误的操作给出异常提示。

Input
输入包含多组测试数据。
首先第一行输入一个数T(T<=10)，表示总共有T组测试数据。
接下来是每组测试数据，第一行是一个数N(N<=100000)，表示总共有N个不同编号(编号从0到N-1)的进程。然后是一个数n(n& lt;=100)，表示ACM系统启动的时候，需要初始化的n个进程。接着n行，都是id、w、address这样的形式出现，表示这n个进程的详细信息。
紧接着是一个数M(M<=200000)，表示总共有M个操作。接着M行，描述的是下面四种中的某一种操作：
1、 Get
2、 Creat ID W ADDRESS
3、 Kill ID
4、 Change ID W

Output
首先，输出Case X：其中X代表是第X组数据(具体格式参照样例)。
对于Get操作，你需要返回最高优先级进程的信息或异常提示(进程池中无进程)。
对于Creat、Kill、Change操作，如果出现了错误操作(新添加进程的编号已经存在了、新添加进程的地址已经被使用了、中止根本不存在的进程、改变不存在进程的权值)，给出异常提示，并忽略该操作；如果上述三种操作都正确，不需要输出任何东西。
对于所有的异常，只需输出“ERROR！”即可。

Sample Input

2
1
1
0 3 0xAAAAAAAA
3
Creat 0 2 0xFFFFFFFF
Kill 0
Get
3
2
0 1 0x11112222
1 2 0x22221111
5
Get
Change 2 2
Kill 1
Get
Kill 1

Sample Output

Case 1:
ERROR!
ERROR!
Case 2:
1 2 0x22221111
ERROR!
0 1 0x11112222
ERROR!

Hint
巨大的输入输出，推荐scanf和printf

Source
humanjustic

题目链接：http://boj.me/onlinejudge/showproblem.php?problem_id=1295

题目要求：

实现某种数据结构，性质如下。

可用于存储元素，元素有三个属性，编号（整数），权值（整数），地址（十六进制表示的整数）。

元素有偏序关系，权值大者优先，编号小者优先（二级比较）。

能够实现如下功能。

1初始化，可以初始化结构中N个元素（利用三个数值）。

2插入新元素，可返回错误信息。（编号重复的报错，地址重复的报错）

3删除已有元素，可返回错误信息。（编号不存在的报错）

4返回最高优先级元素，可返回错误信息。（结构中为空，即无元素报错）

5改变元素的权值，可返回错误信息。（对应编号不存在的报错）

先说感想：

数据结构神马的，要有想象力，但是又不像贪心题和DP题那样需要YY能力。只要YY出能够优化复杂度的结构来即可。（前提是足够的数据结构知识储备和强大的代码能力）

话说这道题的那个神奇的内存地质。。。十六进制数，让我好好学习了一下scanf、printf读入输出指定格式十六进制数，以及cout的格式输出。编程语言的开创者们真是给想好了各种内部优化，不用小菜我再去纠结格式输出的问题。（不然用字符串存地址，铁定超时啊）

Solution：

直观解，该数据结构为堆。根据CLRS，可实现其build、heapify、increase、maximum、insert、delete等全部操作，这些操作的复杂度均为O(logN)（build除外，O(N * LogN)。

但问题在于，传统heap无法实现对于特定编号元素的O(LogN)的查找。

所以配合HASH（两种偷懒的HASH方式，一为int标记数组，二为map映射，分别为O(1)（标记）,O(LogN)（红黑树））。

具体实现：

int to[]，用标记数组记录对应编号元素（数组下标）在堆中的位置（还是数组下标，不过是堆的）

map add，用map将地址映射，用于记录指定地址的存在性

struct node（为了元素的偏序关系才要这个）

（以下每个函数在操作的同时，要维护to数组和add的HASH）

inc函数，对于堆中特定位置的元素，增加其权值到指定值，再逆向维护堆的性质

insert函数，将新加入的元素插在堆尾，再用inc函数增加权值并维护堆性质

heapify函数，从特定位置起，向下正向维护堆性质

del函数，交换堆尾元素与被删元素，再用heapify维护

change函数，如果是权值增加操作则逆向维护堆，反之则正向维护堆

所有函数实现的过程中通过对to数组和add哈希的查找来判断报错与否

#include <iostream>

#include <cstdio>

#include <map>

#include <cstring>

#include <iomanip>

#define left(i) ((i) << 1)

#define right(i) (((i) << 1) + 1)

#define parent(i) ((i) >> 1)

#define WRONG printf("ERROR!\n")

using namespace std;

typedef unsigned long ul;

struct node

{

    int num,value;

    long long addr;

    node(){}

    node(int _num,int _value,ul _addr)

    {

        num = _num;

        value = _value;

        addr = _addr;

    }

    bool friend operator < (const node &a,const node &b)

    {

        return (a.value < b.value) || (a.value == b.value && a.num > b.num );

    }

    void print()

    {

        printf("%d %d 0x%08X\n",num,value,addr);

        //cout.fill('0');

        //cout << setw(8) << HEX << addr << '\n';

        /*for(int i = 31;i >= 0;i -= 4)

        {

            int temp = 0;

            for(int j = 0;j < 4;j++)

                temp += (((value >> (i - j)) & 1) * (1 << (4 - j)));

            printf("%c",(temp > 9) ? (temp - 10 + 'A') : (temp + '0'));

        }

        printf("\n");*/

    }

};

struct heap

{

    map <ul,int> add;

    int to[100005];

    //map  to;//id to index

    node * ele[100005];

    int size;

    heap(int N){size = 0;for(int i = 0;i <= N;i++)to[i] = 0;}

    bool insert(int num,int value,ul addr)

    {

        if(to[num] != 0 || add[addr] != 0)//id existed || addr existed.

            return false;//judge

        ele[++ size] = new node;

        inc(size,num,value,addr);

        return true;

    }

    bool del(int id)

    {

        int pos;

        //cout << "\t\t\tid : " << to[id] << endl;

        if(to[id] == 0)//delete doesn't exist

            return false;

        //cout << "\t\t\tpos : " << to[id] << " id : " << id << endl;

        pos = to[id];

        to[ele[size] -> num] = pos;

        to[id] = 0;

        //cout << "\t\t\tpos : " << to[id] << " id : " << id << endl;

        add[ele[pos] -> addr] = 0;

        swap(ele[pos],ele[size]);

        delete ele[size];

        ele[size] = NULL;

        size--;

        heapify(pos);

        return true;

    }

    bool top()//empty

    {

        if(size < 1)

            return false;

        else

        {

            ele[1] -> print();

            return true;

        }

    }

    void heapify(int pos)

    {

        int l = left(pos),r = right(pos),big;

        if(l <= size && *ele[pos] < *ele[l])

            big = l;

        else

            big = pos;

        if(r <= size && *ele[big] < *ele[r])

            big = r;

        if(big != pos)

        {

            swap(ele[big],ele[pos]);

            swap(to[ele[big] -> num],to[ele[pos] -> num]);

            /*cout << " ---------------------------" << endl;

            cout << ele[big] -> num  << " id " << ele[pos] -> num << endl;

            cout << " ---------------------------" << endl;*/

            heapify(big);

        }

    }

    void inc(int pos,int id,int value,ul ad)

    {

        ele[pos] -> num = id;

        ele[pos] -> value = value;

        ele[pos] -> addr = ad;

        to[id] = pos;

        add[ad] ++;

        int t = pos,pt = parent(pos);

        while(pt >= 1 && !(*ele[t] < *ele[pt]))

        {

            swap(ele[t],ele[pt]);

            swap(to[ele[t] -> num],to[ele[pt] -> num]);

            t = pt;

            pt = parent(t);

        }

    }

    bool change(int num,int value)

    {

        if(to[num] == 0)

            return false;

        int pos = to[num];

        if(ele[pos] -> value > value)

        {

            ele[pos] -> value = value;

            heapify(pos);

        }

        else if(ele[pos] -> value == value)

            ;

        else

        {

            ele[pos] -> value = value;

            int t = pos,pt = parent(pos);

            while(pt >= 1 && !(*ele[t] < *ele[pt]))

            {

                swap(ele[t],ele[pt]);

                swap(to[ele[t] -> num],to[ele[pt] -> num]);

                t = pt;

                pt = parent(t);

            }

        }

        return true;

    }

};

void solve()

{

    int N,n,m;

    scanf("%d",&N);

    scanf("%d",&n);

    heap s(N);

    for(int i = 0;i < n;i++)

    {

        int a,b;

        ul c;

        scanf("%d %d %X",&a,&b,&c);

        s.insert(a,b,c);

        /*cout << endl <<"--------------------AA" << " size : " << s.size << endl;

        for(int j = 1;j <= s.size;j++)

            s.ele[j] -> print();

        cout <<"--------------------AA" << endl << endl;*/

    }

    scanf("%d",&m);

    for(int i = 0;i < m;i++)

    {

        //cout << "option : " << i + 1 << endl;

        char opt[10];

        scanf("%s",opt);

        //cout << opt << " ";

        if(!strcmp(opt,"Get"))

        {

            if(!s.top())

                WRONG;

        }

        else if(!strcmp(opt,"Creat"))

        {

            int a,b;

            ul c;

            scanf("%d %d %X",&a,&b,&c);

            //printf("%d %d 0x%X\n",a,b,c);

            if(!s.insert(a,b,c))

                WRONG;

        }

        else if(!strcmp(opt,"Kill"))

        {

            int a;

            scanf("%d",&a);

            //printf("%d\n",a);

            if(!s.del(a))

                WRONG;

        }

        else if(!strcmp(opt,"Change"))

        {

            int a,b;

            scanf("%d%d",&a,&b);

            //printf("%d %d\n",a,b);

            if(!s.change(a,b))

                WRONG;

        }

        /*cout << endl <<"--------------------AA" << " size : " << s.size << endl;

        for(int j = 1;j <= s.size;j++)

            s.ele[j] -> print();

        cout <<"--------------------AA" << endl << endl;*/

    }

}

int main()

{

    int t;

    freopen("data.in","r",stdin);

    freopen("data3.out","w",stdout);

   // while(scanf("%d",&t) == 1)

    scanf("%d",&t);

    {

        for(int i = 0;i < t;i++)

        {

            printf("Case %d:\n",i + 1);

            solve();

        }

    }

}

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 13:01 发表评论

ZOJ 3409 KKV 【高中物理题】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 04:56:00 GMT

ZOJ Problem Set – 3409

KKV

Time Limit: 10 Seconds Memory Limit: 65536 KB Special Judge

原题链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3409

算法：模拟题、高中动量守恒公式套上三维模板、计算机模拟手解一元二次方程

题目大意：你从(0,0,0)出发，途中经过N-1个点，最后到达第N个点。(N<=40)

这些点均在三维空间中，这N个点的三维坐标均给出。题目背景是太空中的宇宙飞行，故无重力影响，每个点只靠火箭助推器的喷射来改变速度大小和方向。（而且每次动量守恒求解过程中，保证助推器的速度大小均达到最大。速度根据情况而定）故每个拐点的运动改变方式完全符合动量守恒定律（只不过是三维空间的）。

现给你M，总质量，m1，不含所有燃料的火箭剩余质量（1<=M1）,m0，单块燃料（火箭助推器）的质量，v0，每次喷射时火箭助推器的速度。N个点的坐标。

现求解，从第0个点到第N-1个点都有火箭助推器参与的速度改变过程，故问到第N点时所花费的总时间为多少。若无解，则输出无解时对应的报错语句。

现给出代码及注释：

//解法在注释中给出，分别求解一个一元一次方程和一元二次方程即可

还是在之前模拟一下方程吧。防止看不懂

动量守恒定律基本方程。

m1v1+m2v2=m1v1’+m2v2’

此处分别有两次应用（实际上可以规约为一种应用，但是怕挫，就分成两种了）

第一种是初始点0=(m-m0) * v(x,y,z)+m0 * v0(x,y,z)//v和v0分别为三维速度矢量，v为第一次喷射后剩余火箭箭体的速度矢量，v0为第一次喷射燃料时燃料的速度矢量（所以这其实是三个方程联立，解法为同时两边平方再相加）

式中各参量分别满足v0(x)^2+v0(y)^2+v0(z)^2=v0^2//v0已知

v(x,y,z) = k * vec(x,y,z)//vec(x,y,z)为第0点到第一个点的位移矢量

解得K^2= M0^2*V0^2/(Vec^2*(m-m0)^2), k= sqrt(K^2)

所有值均已知，代入即可解得//vec为vec矢量的模长，v0为标量

第二种为一般情况，针对第i个点（1<=I<=n-1）

M’v’(x,y,z)=(m’-m0)v(x,y,z)+m0v0(x,y,z)//实际上三方程联立

v’即为第i-1个点的速度矢量，v为第I个点的速度矢量，m’为第i-1个点剩余的火箭质量

v(x,y,z)=k * vec(x,y,z)//vec为第i个点到第I+1个点的位移矢量

v0x^2+v0Y^2+v0z^2=|v0|^2

将联立方程组左右平方并加和将常数项移到一侧，从而转化为求解k为主元的一元二次方程问题，化归式如下：

(m’- m0) ^ 2 * |vec| ^ 2 * k ^ 2 – 2 * M’ * (m’- m0) * scalar(v’,vec) * k + m’ ^ 2 * |v’| ^ 2 - m0 ^ 2 * |V0| ^ 2 = 0

一元二次方参数：

A=(M’-m0)^2 * |vec| ^ 2

B=-2*M’*(m’-m0)*scalar(v’,vec)

C=M’^2*|v’|^2-M0^2*|v0|^2

det = b^2 – 4 * a * c

判断det有解与否即可

有解则可由v(x,y,z)=k*vec(x,y,z)知道v的矢量及大小

从而算出ti = |vec| / |v|

将第一段与之后的n-1段的时间即可

#include <iostream>

#include <cstdio>

#include <cmath>

using namespace std;

const double eps = 1e-10;

inline double sqr(double x){return x * x;}

struct point

{

       double x,y,z;

       void input()

       {

              scanf("%lf%lf%lf",&x,&y,&z);

       }

}p[50];

struct vect//矢量定义

{

       double x,y,z,mod;

       void init(point p,point q) //矢量初始化并计算模长

       {

              x = q.x - p.x;

              y = q.y - p.y;

              z = q.z - p.z;

              mod = sqrt(sqr(x) + sqr(y) + sqr(z));

       }

       double cal()//对于速度矢量进行计算速率

       {

              return mod = sqrt(sqr(x) + sqr(y) + sqr(z));

       }

}vec[50],v[50]; //位移矢量和速度矢量

double scalar(vect a,vect b) //点积

{

       return a.x * b.x + a.y * b.y + a.z * b.z;

}

void function(double a,double b,double c,bool &mark,double &k1,double &k2)

{ //求解二次方程专用函数

       double det = sqr(b) - 4.0 * a * c; //delta

       if(det < eps && fabs(det) > eps) //delta<0则无解，无解即对应题目中无解情况

       {

              mark = false;

              return ;

       }

       else if(fabs(det) < eps) //唯一解

       {

              mark = true;

              k1 = k2 = -b / (2.0 * a);

              return ;

       }

       else //二解的话一正解一负解舍弃负解即可（貌似最后算出来delta都等于0？我没测试，大概吧。。。我甚至没去手工模拟一下负解所对应的实际情况是怎样的，就直接否决了，因为负解一定不会符合题意，根据我方程的参数即可知道）

       {

              mark = true;

              k1 = (-b - sqrt(det)) / (2.0 * a);

              k2 = (-b + sqrt(det)) / (2.0 * a);

              return ;

       }

}

void solve(int n)

{

       double m,m1,mt,m0,v0,k,t = 0.0,temp;

       int i;

       scanf("%lf%lf%lf%lf",&m,&m1,&m0,&v0);

       p[0].x = p[0].y = p[0].z = 0.0;

       for(i = 1;i <= n;i++)

       {

              p[i].input();

              vec[i - 1].init(p[i - 1],p[i]); //位移矢量初始化

       }

       //p[0] //对于原点处速度矢量和第一段距离的时间的求解

       /*

          0 = (M-m0)*Vx - m0*V0x //其实可以列一个三元一次方程组用行列式解，我嫌麻烦

          0 = (M-m0)*Vy - m0*V0y //也可以用纯几何的点积叉积做，我不会~算了~

          0 = (M-m0)*Vz - m0*V0z

          (Vx,Vy,Vz) = k * (Vecx,Vecy,Vecz) //求解对象即为k，因为速度矢量方向确定，但是大小不确定，解出大小即可

          V0x^2 + V0y^2 + V0z^2 = V0^2 //V0作为已知量，要做好未知量的化归转化，才方便求出可行解

          t0 = |Vec0| / |V[0]| //标量除法

          t += t0

          */

       mt = m - m0; //第一次后剩余质量

       k = sqrt(sqr(m0) * sqr(v0) / sqr(mt) / sqr(vec[0].mod));

       v[0].x = k * vec[0].x;

       v[0].y = k * vec[0].y;

       v[0].z = k * vec[0].z;

       temp = vec[0].mod / v[0].cal();

       t += temp;

//对于一般点处，求解一般方程

       /*

          ti = |Veci| / |V[i]|

          Mt * Vx[i - 1] = (Mt - m0) * Vx[i] + m0 * V0x

          Mt * Vy[i - 1] = (Mt - m0) * Vy[i] + m0 * V0y

          Mt * Vz[i - 1] = (Mt - m0) * Vz[i] + m0 * V0z

          V[i](x,y,z) = k * Vec[i](x,y,z)

          V0x^2 + V0y^2 + V0z^2 = V0^2

          k^2*|Vec[i]|^2*(Mt-m0)^2 - 2*Mt(Mt-m0)*k*(scalar(Vec[i],V[i-1])) + Mt^2*|V[i-1]|^2 - m0^2*|V0|^2 = 0

          */

       for(i = 1;i < n;i++)

       {

              double k1,k2;

              double a,b,c;

              bool mark = true;

              a = sqr(vec[i].mod) * sqr(mt - m0);

              b = -2.0 * mt * (mt - m0) * scalar(vec[i],v[i - 1]);

              c = sqr(mt) * sqr(v[i - 1].cal()) - sqr(m0) * sqr(v0);

           function(a,b,c,mark,k1,k2);

              if(mark)

              {

                     if(k1 > 0)

                            k = k1;

                     if(k2 > 0)

                            k = k2;

                     v[i].x = k * vec[i].x;

                     v[i].y = k * vec[i].y;

                     v[i].z = k * vec[i].z;

                     temp = vec[i].mod / v[i].cal();

                     t += temp;

              }

              else

              {

                     printf("Another kind of KKV.\n");

                     return ;

              }

              mt = mt - m0;

       }

       printf("%.2lf\n",t);

}

int main()

{

       //freopen("3409.in","r",stdin);

       int n;

       while(scanf("%d",&n) != EOF)

       {

              solve(n);

       }

}

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 12:56 发表评论