[费用流 高精度类 分数类] AOJ 2691 Cost Performance Flow

最新推荐文章于 2021-08-23 15:04:33 发布
最新推荐文章于 2021-08-23 15:04:33 发布
阅读量507 收藏
点赞数
分类专栏： 网络流 高精度&FastIO模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014609452/article/details/60149283
版权

根据费用流增广的特点
费用和流量肯定是一条凸的分段函数
考虑的答案的几何意义
就是一个点到这条函数的最短距离 直接一段段求就好了
ps 这个题输出小数不就好了 结果输分数
就拉了个分数类 不会__int128 就又拉了个高精度类
总之这道题让我很桑心啊

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<vector>
#include<cstring>
using namespace std;
typedef long long ll;
typedef long double ld;

class Int{
#define BASE 1000000000
public:
  typedef long long value;
  void New(size_t l){
    if (a!=NULL)delete[] a;a=new value[l];
    len=1;a[0]=0;sign=1;
  }
  Int():a(NULL),base(BASE){New(1);}
  Int(value x):a(NULL),base(BASE){New(1);*this=x;}
  Int(value x,value _base):a(NULL),base(_base){New(1);*this=x;}
  Int(const Int &B):a(NULL),base(BASE){New(1);*this=B;}
  ~Int(){delete[] a;}
  Int& operator =(value x){
    size_t l=1;for (value x1=max(x,-x);x1>=base;++l,x1/=base);New(l);
    if (x<0)x=-x,sign=0;else sign=1;
    len=0;while (x)a[len++]=x%base,x/=base;
    if (!len)a[len++]=0;
    return *this;
  }
  Int& operator =(const Int &A){
    New(A.len);len=A.len;memcpy(a,A.a,sizeof(value)*len);
    base=A.base;sign=A.sign;return *this;
  }
  friend Int operator -(Int A){A.sign=1-A.sign;return A;}
  bool operator !(){if (len==1&&a[0]==0)return 1;else return 0;}
  friend Int operator +(Int A,Int B){
    if (A.sign!=B.sign){B.sign=1-B.sign;return A-B;}
    if (A.base!=B.base)
      if (A.base>B.base)B.set_base(A.base);
      else A.set_base(B.base);
    Int res;res.set_base(A.base); int len=A.len>B.len?A.len:B.len;
    res.New(len+1);res.sign=A.sign;
    memset(res.a,0,(len+1)*sizeof(value));
    for (int i=0;i<len;++i){
      if (i<A.len)res.a[i]+=A.a[i];
      if (i<B.len)res.a[i]+=B.a[i];
    }
    for (int i=0;i<len;++i)
      if (res.a[i]>=res.base)++res.a[i+1],res.a[i]-=res.base;
    if (res.a[len])res.len=len+1;else res.len=len;
    if (!res)res.sign=1;return res;
  }
  friend Int operator -(Int A,Int B){
    if (A.sign!=B.sign){B.sign=1-B.sign;return A+B;}
    if (A.base!=B.base)
      if (A.base>B.base)B.set_base(A.base);
      else A.set_base(B.base);
    if (small(A,B))swap(A,B),A.sign=1-A.sign;
    Int res;res.set_base(A.base); int len=A.len>B.len?A.len:B.len;
    res.New(len);res.sign=A.sign;
    memset(res.a,0,len*sizeof(value));
    for (int i=0;i<len;++i){
      if (i>=B.len)res.a[i]+=A.a[i];
      else res.a[i]+=A.a[i]-B.a[i];
      if (res.a[i]<0)res.a[i]+=res.base,--res.a[i+1];
    }
    while (len>1&&!res.a[len-1])--len;res.len=len;
    if (!res)res.sign=1;return res;
  }
  friend Int operator *(Int A,Int B){
    if (A.base!=B.base)
      if (A.base>B.base)B.set_base(A.base);
      else A.set_base(B.base);
    Int res;res.set_base(A.base); int len=A.len+B.len;
    res.New(len);res.sign=(A.sign==B.sign);
    memset(res.a,0,len*sizeof(value));
    for (int i=0;i<A.len;++i)
      for (int j=0;j<B.len;++j){
    res.a[i+j]+=A.a[i]*B.a[j];
    res.a[i+j+1]+=res.a[i+j]/res.base;
    res.a[i+j]%=res.base;
      }
    /*
      for (int i=0;i<A.len;++i)
      for (int j=0;j<B.len;++j)res.a[i+j]+=A.a[i]*B.a[j];
      for (int i=0;i<len-1;++i)res.a[i+1]+=res.a[i]/res.base,res.a[i]%=res.base;
    */
    while (len>1&&!res.a[len-1])--len;res.len=len;
    return res;
  }
  friend pair<Int,Int> divide(Int A,Int B){
    if (!B){puts("error:div zero!");for (;;);}
    if (A.base!=B.base)
      if (A.base>B.base)B.set_base(A.base);
      else A.set_base(B.base);
    if (small(A,B))return make_pair(Int(0),A);
    Int C,D;C.set_base(A.base);D.set_base(A.base);C.New(A.len);C.len=A.len;
    bool Csign=(A.sign==B.sign),Dsign=A.sign;A.sign=B.sign=1;
    for (int i=A.len-1;i>=0;--i){
      C.a[i]=0;D=D*D.base;D.a[0]=A.a[i];
      int l=0,r=A.base-1,mid;
      while (l<r){
    mid=(l+r+1)>>1;
    if (small(B*mid,D+1))l=mid;
    else r=mid-1;
      }
      C.a[i]=l;D=D-B*l;
    }
    C.sign=Csign;D.sign=Dsign;if (!D)D.sign=1;
    while (C.len>1&&!C.a[C.len-1])--C.len;
    return make_pair(C,D);
  }
  Int operator /(value x){
    if (!x){puts("error:div zero!");for (;;);}
    value d=0;Int res;res.set_base(base);res.New(len);res.len=len;
    if (x<0)x=-x,res.sign=(sign==0);
    else res.sign=(sign==1);
    for (int i=len-1;i>=0;--i)
      d=d*base+a[i],res.a[i]=d/x,d%=x;
    while (res.len>1&&!res.a[res.len-1])--res.len;
    return res;
  }
  Int operator %(value x){
    value d=0;if (x<0)x=-x;
    for (int i=len-1;i>=0;--i)d=(d*base+a[i])%x;
    return d;
  }
  friend Int abs(Int A){A.sign=1;return A;}
  friend bool small(Int A,Int B){
    if (A.base!=B.base)
      if (A.base>B.base)B.set_base(A.base);
      else A.set_base(B.base);
    if (A.len!=B.len)return A.len<B.len;
    for (int i=A.len-1;i>=0;--i)
      if (A.a[i]!=B.a[i])return A.a[i]<B.a[i];
    return 0;
  }
  friend bool operator <(Int A,Int B){
    if (A.sign!=B.sign)return A.sign<B.sign;
    return A.sign==1?small(A,B):small(B,A);
  }
  friend bool operator ==(Int A,Int B){
    if (A.base!=B.base)
      if (A.base>B.base)B.set_base(A.base);
      else A.set_base(B.base);
    if (A.sign!=B.sign||A.len!=B.len)return 0;
    for (int i=0;i<A.len;++i)if (A.a[i]!=B.a[i])return 0;
    return 1;
  }
  friend bool operator !=(Int A,Int B){return !(A==B);}
  friend bool operator >(Int A,Int B){return !(A<B||A==B);}
  friend bool operator <=(Int A,Int B){return A<B||A==B;}
  friend bool operator >=(Int A,Int B){return A>B||A==B;}
  Int operator /(Int B){return divide(*this,B).first;}
  Int operator %(Int B){return divide(*this,B).second;}
  Int& operator +=(Int B){*this=*this+B;return *this;}
  Int& operator -=(Int B){*this=*this-B;return *this;}
  Int& operator *=(Int B){*this=*this*B;return *this;}
  Int& operator /=(Int B){*this=*this/B;return *this;}
  Int& operator %=(Int B){*this=*this%B;return *this;}
  Int& operator ++(){*this=*this+1;return *this;}
  Int& operator --(){*this=*this-1;return *this;}
  Int operator ++(int){Int res(*this);*this=*this+1;return res;}
  Int operator --(int){Int res(*this);*this=*this-1;return res;}
  Int operator +(value x){return *this+Int(x,this->base);}
  Int operator -(value x){return *this-Int(x,this->base);}
  Int operator *(value x){return *this*Int(x,this->base);}
  //Int operator /(value x){Int T;T=x;return *this/T;}
  //Int operator %(value x){Int T;T=x;return *this%T;}
  Int& operator *=(value x){*this=*this*x;return *this;}
  Int& operator +=(value x){*this=*this+x;return *this;}
  Int& operator -=(value x){*this=*this-x;return *this;}
  Int& operator /=(value x){*this=*this/x;return *this;}
  Int& operator %=(value x){*this=*this%x;return *this;}
  bool operator ==(value x){return *this==Int(x,this->base);}
  bool operator !=(value x){return *this!=Int(x,this->base);}
  bool operator <=(value x){return *this<=Int(x,this->base);}
  bool operator >=(value x){return *this>=Int(x,this->base);}
  bool operator <(value x){return *this<Int(x,this->base);}
  bool operator >(value x){return *this>Int(x,this->base);}
  friend Int gcd(Int x,Int y){
    Int t;int cnt=0;
    while (1){
      if (x<y)t=x,x=y,y=t;
      if (y==0){
    while (cnt--)x*=2;
    return x;
      }
      if (x%2==0&&y%2==0)x/=2,y/=2,++cnt;
      else if (x%2==0)x/=2;
      else if (y%2==0)y/=2;
      else {t=x;x=y;y=t-y;}
    }
  }
  void to_arr(char *c){
    char *c1=c;
    for (int i=0;i<len-1;++i)
      for (value x=a[i],b=base/10;b>=1;b/=10)*c1++='0'+x%10,x/=10;
    for (value x=a[len-1];x>0;x/=10)*c1++='0'+x%10;
    if (len==1&&a[len]==0)*c1++='0';
    if (sign==0)*c1++='-';*c1=0;reverse(c,c1);
  }
  void from_arr(char *c){
    size_t base_l=get_basel(),b=1;int cl=strlen(c);value x=0;
    New((cl+base_l-1)/base_l);len=0;
    if (*c=='-')sign=0,++c,--cl;else sign=1;
    while (--cl>=0){
      x+=(c[cl]-'0')*b;b*=10;if (b==base)a[len++]=x,x=0,b=1;
    }
    if (!len||x)a[len++]=x;
    while (len>1&&!a[len-1])--len;
  }
  void set_base(int _base){
    if (base==_base)return;
    char *c=new char[len*get_basel()+1];
    to_arr(c);base=_base;from_arr(c);
    delete[] c;
  }
  void set_basel(int _l){
    size_t _base=1;while (_l--)_base*=10;set_base(_base);
  }
  void read(){
    vector<char> s;char ch;
    scanf(" %c",&ch);if (ch=='-')s.push_back('-'),ch=getchar();
    for (;ch>='0'&&ch<='9';ch=getchar())s.push_back(ch);
    char *c=new char[s.size()+1];
    for (int i=0;i<s.size();++i)c[i]=s[i];c[s.size()]=0;
    from_arr(c);delete[] c;
    if (!*this)this->sign=1;
  }
  void print(){
    if (!sign)putchar('-');
    printf("%d",int(a[len-1]));
    for (int i=len-2;i>=0;--i){
      for (int j=base/10;j>=10;j/=10)
    if (a[i]<j)putchar('0');
    else break;
      printf("%d",(int)a[i]);
    }
  }
  void println(){print();putchar('\n');}
private:
  value *a,base;int len;bool sign;  //0="-"
  size_t get_basel()const{
    size_t res=0;for (int b=base/10;b>=1;b/=10,++res);
    return res;
  }
#undef BASE
};

namespace Frac{
  typedef long long vint;
  struct frac{
    frac(vint a=1,vint b=1);  
    virtual ~frac(){};  
    long double value()const;
    void sim();
    friend ostream& operator<<(ostream& os,frac& f);
    frac operator +(const frac& f)const;  
    frac operator -(const frac& f)const;  
    frac operator *(const frac& f)const;  
    frac operator /(frac f)const;  
    bool operator ==(const frac& f)const;  
    bool operator >(const frac& f)const;  
    bool operator <(const frac& f)const;  
    frac rev();
    void ChangeValue(vint a,vint b);
    vint u,d;
    bool neg;
  };
  vint Function(vint& a,vint& b)  {  
    vint r=a%b;  
    while(r) a=b,b=r,r=a%b; 
    return b;  
  }  
  ostream& operator<<(ostream& os,frac& f)  {  
    f.sim();  
    if(f.neg) os<<"-"<<f.u<<"/"<<f.d<<endl;  
    else os<<""<<f.u<<"/"<<f.d<<endl;  
    return os;  
  }  
  frac::frac(vint a, vint b):neg(false){ 
    while(b==0){ }  
    this->u=abs(a); this->d=abs(b);  
    if(a<0&&b<0) this->neg=false;  
    else if(a<0||b<0) this->neg=true;  
    else this->neg=false;  
    this->sim();  
  }  
  long double frac::value()const{  
    return this->u/(long double)d;  
  }  
  void frac::sim(){  
    vint a=u,b=d;  
    vint ret=Function(a,b);  
    u/=ret; d/=ret;  
  }  
  frac frac::operator +(const frac &f)const{  
    frac temp;  
    if(neg==f.neg){  
      temp.u=u*f.d+d*f.u; temp.d=d*f.d; temp.neg=neg;  
    }  
    else{  
      temp.u=abs(u*f.d-d*f.u); temp.d=abs(d*f.d);  
      if(this->value()>f.value())  
    temp.neg=neg;  
      else  
    temp.neg=f.neg;  
    }
    temp.sim();
    return temp;  
  }
  frac frac::operator -(const frac &f) const{  
    frac temp;  
    if(neg==f.neg){  
      temp.u=abs(u*f.d-d*f.u); temp.d=d*f.d;  
      if(value()>=f.value()) temp.neg=false;  
      else temp.neg=true;  
    }  
    else{ 
      temp.u=u*f.d+d*f.u; temp.d=d*f.d;  
      temp.neg=neg;  
    }  
    temp.sim();
    return temp;  
  }  
  frac frac::operator *(const frac &f) const{  
    frac temp;  
    temp.u=u*f.u; temp.d=d*f.d;
    if(neg==f.neg) temp.neg=false;  
    else temp.neg=true;
    temp.sim();
    return temp;  
  }  
  frac frac::operator /(frac f) const {  
    frac temp,r; r=f.rev(); temp=*this*r; 
    temp.sim();return temp;  
  }  
  frac frac::rev() {  
    frac temp;  
    temp.d=u; temp.u=d; temp.neg=neg;  
    return temp;  
  }  
  bool frac::operator ==(const frac &f) const{  
    if(neg!=f.neg) return false;  
    if(value()==f.value()) return true;  
    else return false;  
  }  
  bool frac::operator <(const frac &f) const{  
    if(neg==f.neg){ 
      if(value()<f.value()){  
    if(neg) return false;  
    else return true;  
      }  
      else if(value()>f.value()){  
    if(neg) return true;  
    else return false;  
      }  
      else return false;  
    }  
    else
      if(neg) return true;  
      else return false;  
  }  
  bool frac::operator >(const frac& f)const { 
    return (f<*this);  
  }  
  void frac::ChangeValue(vint a,vint b)  {  
    *this=frac(a,b);  
  }
}
using namespace Frac;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const int N=1005;

struct edge{
  int u,v,w,f,next;
}G[N<<1];
int head[N],inum=1;
inline void add(int u,int v,int w,int f,int p){
  G[p].u=u; G[p].v=v; G[p].w=w; G[p].f=f; G[p].next=head[u]; head[u]=p;
}
inline void link(int u,int v,int w,int f){
  add(u,v,w,f,++inum); add(v,u,-w,0,++inum);
}

struct PP{
  ll x,y;
  PP(ll x=0,ll y=0):x(x),y(y) { }
  friend PP operator + (PP A,PP B){ return PP(A.x+B.x,A.y+B.y); }
  friend PP operator - (PP A,PP B){ return PP(A.x-B.x,A.y-B.y); }
  friend ll operator * (PP A,PP B){ return A.x*B.x+A.y*B.y; }
}pt[100005],p0;
int tot;

int n,m,S,T;

int dis[N],pre[N],ins[N];
int Q[5000005],l,r;
#define V G[p].v
inline bool SPFA(){
  l=r=-1;
  for (int i=1;i<=n;i++) dis[i]=1<<30,pre[i]=0,ins[i]=0;
  Q[++r]=S; dis[S]=0; ins[S]=1;
  while (l<r){
    int u=Q[++l]; ins[u]=0;
    for (int p=head[u];p;p=G[p].next)
      if (G[p].f && dis[V]>dis[u]+G[p].w){
    dis[V]=dis[u]+G[p].w; pre[V]=p;
    if (!ins[V]) Q[++r]=V,ins[V]=1;
      }
  }
  if (dis[T]==1<<30) return 0;
  int minv=1<<30;
  for (int p=pre[T];p;p=pre[G[p].u])
    minv=min(minv,G[p].f);
  for (int p=pre[T];p;p=pre[G[p].u])
    G[p].f-=minv,G[p^1].f+=minv;
  pt[++tot]=PP(pt[tot-1].x+minv,pt[tot-1].y+minv*dis[T]);
  return 1;
}

ld ans=1e20;
frac ax,ay;

inline void Solve(PP p1,PP p2,PP p0){
  ll r1=(p2-p1)*(p0-p1),r2=(p1-p2)*(p0-p2);
  frac x1=frac(p1.x,1),y1=frac(p1.y,1);
  frac x2=frac(p2.x,1),y2=frac(p2.y,1);
  frac x0=frac(p0.x,1),y0=frac(p0.y,1);
  if (r1>0 && r2>0){
    frac k=(y2-y1)/(x2-x1);
    frac x=(x0/k+y0+k*x1-y1)/(k+k.rev());
    frac y=k*(x-x1)+y1;
    ld dx=(x-x0).value();
    ld dy=(y-y0).value();
    ld d=dx*dx+dy*dy;
    if (d<ans)
      ans=d,ax=x,ay=y;
  }else if (r1<=0){
    ld dx=(x1-x0).value();
    ld dy=(y1-y0).value();
    ld d=dx*dx+dy*dy;
    if (d<ans)
      ans=d,ax=x1,ay=y1;
  }else {
    ld dx=(x2-x0).value();
    ld dy=(y2-y0).value();
    ld d=dx*dx+dy*dy;
    if (d<ans)
      ans=d,ax=x2,ay=y2;
  }
}

int main(){
  int _u,_v,_f,_w;
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(n); read(m); read(S); read(T);
  for (int i=1;i<=m;i++)
    read(_u),read(_v),read(_f),read(_w),link(_u,_v,_w,_f);
  pt[++tot]=PP(0,0);
  while (SPFA());
  p0=PP(pt[tot].x,0);
  if (tot==1)
    return printf("0/1\n"),0;
  for (int i=1;i<tot;i++)
    Solve(pt[i],pt[i+1],p0);
  frac dx=ax-pt[tot].x,dy=ay;
  Int a=dx.d,b=dx.u,c=dy.d,d=dy.u;
  a=a*a; b=b*b; c=c*c; d=d*d;
  Int ans_u=b*c+a*d,ans_d=a*c,g=gcd(ans_u,ans_d);
  ans_u/=g; ans_d/=g;
  ans_u.print(); putchar('/'); ans_d.print(); putchar('\n');
  return 0;
}
里阿奴摩西
关注
专栏目录
【高精度】高精度分数[c++]
银狼的黎明
03-07 1106
题目描述 “人无远虑，必有近忧”是修罗王一直以来恪守的信条，为了以防万一，他在很久以前就将《魔法宝典》的全部信息编码为一个巨大无比的自然数，并在这个数前加一个0和小数点，使它变成一个分数。然后他在戒指上刻了一个记号，使记号的两端长度比等于这个分数。这样，虽然他在入狱时手上只带了一个戒指
AOJ
03-29
"AOJ"，这个名字在IT领域中通常指的是Algorithms Online Judge，一个著名的在线编程练习平台，专注于算法和数据结构的学习与实践。这个平台提供了一系列的编程题目，用户可以通过提交代码来解决这些问题，并获取即时...
P3705 [SDOI2017]新生舞会(分数规划&费用流)
Harris-H的博客
08-23 260
P3705 [SDOI2017]新生舞会(分数规划&费用流) 显然二分后，然后就是找nnn对 满足属性值∑ai,j−mid×bi,j≥0\sum a_{i,j}-mid\times b_{i,j}\ge 0∑ai,j​−mid×bi,j​≥0。 因为每行每列只有一个点，可以使用费用流，源点与每行流量为1，费用为0，汇点与每列流量为 1，费用为0. 第iii行jjj列连边ai,j−mid×bi,ja_{i,j}-mid\times b_{i,j}ai,j​−mid×bi,j​。 然后跑最大费用流即可。
[bzoj4819][01分数规划][网络流-费用流]新生舞会
Rose_max的博客
01-25 292
Description 学校组织了一次新生舞会，Cathy作为经验丰富的老学姐，负责为同学们安排舞伴。有n个男生和n个女生参加舞会 买一个男生和一个女生一起跳舞，互为舞伴。Cathy收集了这些同学之间的关系，比如两个人之前认识没计算得出 a[i][j] ，表示第i个男生和第j个女生一起跳舞时他们的喜悦程度。Cathy还需要考虑两个人一起跳舞是否方便， 比如身高体重差别会不会太
费用流
10-03 122
边们增加了费用 求费用最少的最大流 在残余网络中，用spfa跑费用的最短路，然后沿着这条花费最少的增广路进行增广 （表示怀疑这样做的时间复杂度会比较高 因为他甚至都没有沿着分层图上最短路去增广...不过貌似没有别的办法...） 看起来很容易出现负圈并且死循环的样子 负圈的问题感觉大佬解释得比较清楚： 在费用最短路增广的过程中产生的剩余网络不可能存在负圈，原因是最短增广路...
BZOJ 2245 SDOI 2011 工作安排 费用流
(╯°口°)╯(┴—┴
10-09 1145
题目大意：有一些商品需要被制造，有一些员工，每一个员工会做一些物品，然而这些员工做物品越多，他们的愤怒值越大，这满足一个分段函数。给出哪些员工可以做哪些东西，给出这些分段函数，求最小的愤怒值以满足需要被制造的商品。 思路：费用流。我写的朴素费用流好像很慢，有时间学一学费用流的多路增广。 由于题目中满足那些分段函数是满足单调递增的性质的，所以就可以如下建图： S->每个人，费用0，流量
AOJ-开源
05-26
开发者可以通过解压这个文件夹，查看AOJ框架的实现细节，包括类、接口以及它们的实现方式，这有助于理解框架的工作原理和如何在实际项目中应用。 AOJ框架的开源性质是其另一个关键特性。开源软件意味着源代码对公众...
leetcode二叉树题目图解-procon-study-group:AOJ代码（日文）
06-30
(AOJ: sotetsuk, POJ: sotetsuk, AtCoder: sotetsuk) @nishimuuu (AOJ: nishimuuuuuu) @ryof（AOJ：ryof） @ chiiia12 (AOJ: chiiia12) @kikunantoka（AOJ：kikunantoka，AtCoder：kikunantoka） @toiroakr（AOJ：a_...
leetcode1004-aoj:AOJ
07-01
20200125_esy_746_min_cost_climbing_stairs.py OK 20200126全部/所有媒体20200126 20200126_esy_1137_nth_tribonacci_number.py NG 20200124全部/所有媒体20200124 20200123_hrd_630_course_schedule_iii NG ...
AIZU ONLINE JUDGE （会津大学在线测评，简称AOJ）
common_heart的博客
09-28 3222
    AOJ 官网地址：http:judge.u-aizu.ac.jp 最近在看《挑战程序设计竞赛||算法和数据结构》一书，书中大量例题均收录在AOJ测评系统上面，为了更好的练习巩固知识，免费注册了账号。（Windows10 下面用Chrome浏览器注册失败后，转向win10自带浏览器Edge注册成功），有了账号就可以在上面挑（zhao）战（nve）啦、找了到冒泡排序练了一手，最后看到绿色...
【AOJ】AOJ使用方法（《挑战程序设计竞赛》习题）
ZAX130的博客
11-26 4157
AOJ使用方法（《挑战程序设计竞赛》习题） 目录: AOJ使用方法（《挑战程序设计竞赛》习题）一、网址二、注册三、查找题目四、做题五、用virtual judge做AOJ的题目 一、网址 https://onlinejudge.u-aizu.ac.jp/home 二、注册 点右上角Guest->Sign Up 填写后点击submit 三、查找题目 以查找AOJ0189为例: 1.点击网站...
高精度分数
Scott_Wong06的博客
02-01 433
问题 E: 【高精度】高精度分数 时间限制: 1 Sec  内存限制: 64 MB 提交: 73  解决: 21 [提交][状态][讨论版] 题目描述 “人无远虑，必有近忧”是修罗王一直以来恪守的信条，为了以防万一，他在很久以前就将《魔法宝典》的全部信息编码为一个巨大无比的自然数，并在这个数前加一个0和小数点，使它变成一个分数。然后他在戒指上刻了一个记号，使记号的两端长度比等于这个分数。
计算分数的精确值－高精度除法
逐梦者
06-28 4921
描述计算分数的精确值。使用数组精确计算M / N(0 < M < N ≤ 100)的值。如果M / N是无限小数或小数部分超过20位，则精度要求小数点后20位，并输出。说明由于计算机内字长有限，常规的浮点数运算都有精度限制，为了得到高精度的计算结果，就必须自行设计算法，这里涉及到的算法是高精度算法中的除法。提示可以将商存放在一维数组中，进行除法运算，可模拟人的手工操作，即每次求出商的一位后，将余数乘
C/C++之高精度大数问题
weixin_44575660的博客
04-29 1477
问题一高精度加法 问题描述 　　在C/C++语言中，整型所能表示的范围一般为-231到231（大约21亿）,即使long long型，一般也只能表示到-263到263。要想计算更加规模的数，就要用软件来扩展了，比如用数组或字符串来模拟更多规模的数及共运算。 　　现在输入两个整数，请输出它们的和。 输入格式 　　两行，每行一个整数，每个整数不超过1000位 输出格式 　　一行，两个整数的和。 样例输...
[DP 上下界最小流] BZOJ4200 [Noi2015]小园丁与老司机
雯舞
03-16 1862
膜拜大神题解： http://blog.csdn.net/popoqqq/article/details/47402925 http://www.cnblogs.com/maijing/p/4689740.html 不管怎么说，参观了很多大神的代码，还是把老司机给A掉了 第一二问 DP 但是细节很多 码出来的神犇很强 自己代码能力太差 然后之后还得来个DP 与第一遍方向相反 就是
[费用流建模] Codeforces Gym 101190 NEERC 16 D. Delight for a Cat
雯舞
03-12 1593
很好的建模题 首先变换一下 默认每天都sleep 那么eat的价值就是这一天两个值的差值 每KK天eat的次数必须在[mine,maxe][min_e,max_e]之间 然后我们在变换一下 KK天这个区间[i−K+1,i][i-K+1,i]变成区间末尾ii表示 第ii天eat 能够对[i,min(i+K−1,n)][i,min(i+K-1,n)]天都产生贡献 这样我们就得到了这样一个问题 选
[最大权闭合子图] BZOJ 4873 [Shoi2017]寿司餐厅
雯舞
05-02 1401
一直以为是DP 结果是网络流 orz WrongAnswer#include<cstdio> #include<cstdlib> #include<algorithm> #include<cstring> using namespace std; typedef long long ll;inline char nc(){ static char buf[100000],*p1=buf,*p
[费用流] ICPC 2016 China Final J. Mr.Panda and TubeMaster
雯舞
03-29 1321
传送门dls实在是太强啦 可能是我姿势不够高 自己瞎弄弄出个 带下界带正环最大费用循环流 先加超级源汇SS和TT 去下界 转成 带正环最大费用最大流 然后再加超超级源汇S和T 跑一边最大费用最大流 消掉正环 正环没了后 再在SS和TT上跑最大费用最大流 嗯 费用流练习题#include<cstdio> #include<cstdlib> #include<algorithm> using
[最大费用可行流 || 单纯形] BZOJ 3118 Orz the MST
雯舞
09-20 1308
首先很容易根据树边非树边的大小关系列出线性关系 然后对偶一下 可以用线性规划 也可以跑费用流 把对偶后的线性约束写出来 建图就不难看懂了 #include #include #include using namespace std; inline char nc(){ static char buf[100000],*p1=buf,*p2=buf; if (p1==p2
澳泰AOL/AOJ5000系列智能流量控制器用户手册
AOL/AOJ5000系列智能流量积算控制器是福建澳泰自动化设备有限公司推出的一款高性能仪表，它能够精确地处理和显示工业过程中的流量参数。该系列仪表提供不同尺寸和配置选项，包括H8（160×80mm横表）、V8（80×160mm...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值