Tricks

• For each A(i)>0, add S-->X(i) with capacity A(i).  (X(i)=1 <===> S-->X(i) not in the cut)
  
• For each A(i)<0, add X(i)-->T with capacity -A(i).
• For each B(i)>0, add Y(i)-->T with capacity B(i). (Y(i)=1 <===> Y(i)-->T not in the cut)
  
• For each B(i)<0, add S-->Y(i) with capacity -B(i).
  
• For each C(i,j)>0, add X(i)-->Y(j) with capacity C(i,j).

    星座特征

    非常需要爱与安定的星座。爱猜疑的个性，使他们在人生旅途上处处显得缺乏安全感。但是带着母爱光辉的巨蟹，为了所爱倒是心甘情愿的付出。

    巨蟹座的人天生具有旺盛的精力和敏锐的感觉，道德意识很强烈，对欲望的追求也总能适度的停止。有精辟的洞察能力，自尊心也很强，同时也生性慷慨、感情丰 富，乐意帮助有需要的人，并喜欢被需要与被保护的感觉。大部份巨蟹座的人都比较内向、羞怯，虽然他们常用一种很表面的夸张方式来表达，但基本上他们是缺乏 自信的，也不太能适应新的环境。虽然对新的事物都很感兴趣，但真实却是很传统、恋旧的，似乎看来有些双重个性；如果换一个角度来看，他们只是对情绪的感受 力特别强吧！

    巨蟹座是十二星座中最具有母性的星座，男性亦然。和善、体贴、宽容不记仇，对家人与好朋友非常忠诚。记忆力很好，求知欲很强，顺从性强，想象力也极丰富。

    他们的守护星是月亮，所以只要观察它就可揣测出他们的心情变化；他们喜欢探索别人的秘密，却把自己隐藏的很好，并且从不放弃他所要的东西。

    性格代表词语：我觉得

    守护星：月亮（象征情绪和感觉）

    守护神：希腊－阿特密斯　罗马－戴安娜

    星座爱情

    蟹子是典型女性气质星座，感情丰富又敏感，虽然他们总是装作坚强，一副不在乎的模样。尤其受到月亮影响，情绪变化让人无法理解。他们会如慈母般照顾对方，同样也需要情人呵护、疼爱的行动与保证。否则蟹子们很容易被“诱拐”出走。

    巨蟹经常表现得很吊诡，缺乏安全感；所以他们需要一个安全温暖的窝，和一双坚强的臂膀，还必须让他们有被爱的感觉，切记哦！要他们有感觉才行！

1. Usage of "const"
   char greeting[]="Hello";
   const char *p=greeting; //const data
   char * const p=greeting; //const pointer
   const char* const p=greeting; //const pointer and data
   void fun() const; // Declaration of constant member function
   
2. When a derived class of object is deleted through a pointer to a base class with
   a non-virtual destructor, results are undefined. So a class containing any virtual
   function should has a virtual destructor.
   A bad example.
   class base
   {
       //public:
           //virtual ~base(){};
   };
   class derive:public base
   {
       int *a;
       public:
           derive(){a=new int[10];};
           ~derive(){delete [] a;cout<<"deleted"<<endl;};
   };
   int main()
   {
       base *p=new derive();
       delete p;  // ~derive would never be called.
       return 0;
   }
   
3. operator=
   class Widget {private: Bitmap *pb;}
   Widget& Widget::operator=(const Widget& rhs)
   {
       delete pb;
       pb=new Bitmap(*rhs.pb);
       return *this;
   }
   Widget obj;
   obj=obj;  //  Oops! runtime error
4. std::auto_ptr<>;
   void fun()
   {
       std::auto_ptr<myclass> pp(new myclass());
       ...
   }
   When fun() exits, the object will be deleted automatically.
   Another better choice is std::tr1::shared_ptr<>
5. Type cast
   
   • const_cast<T>():  Remove const property.
     const char str[]="aaa";
     char *p=str;  // Can't compile
     char *p=const_cast<char*>(str);
     
   • dynamic_cast<T>(): Perform safe downcasting, i.e. casta base class type into derived class type.
     It will check whether the base object is actually a derived object in run time, it not the cast will fail in run time.
     class base{public: virtual void f(){};};
     class derived: public base{public: void print(){puts("derived");};};
     int main()
     {
         derived obj;
         base *p=&obj;
         dynamic_cast<derived*>(p)->print();
         return 0;
     }
     The base class must be polymorphic.
   • reinterpret_cast<T>(): low-level casts.
     pointer --> int
   • static_cast<T>(): force implicit conversions. e.g. non-const object
     to const object, int to double. Perform reverse of many such conversions.
     It can't assure the correct cast like dynamic_cast<>.
     e.g. void* to typed*, pointer-to-base to pointer-to-derived. It can cast const to non-const.
     
6. Pointer to class member function
   double      \\return type
   ( Point::*  \\class name
     pmf )       \\name of pointer
    ();             \\argument list
   pmf can point to a virtual function, and the polymorphism still holds.
7. class base
   {
       public:
           virtual void fun1()=0;
           virtual void fun2()=0;
           void fun3();
   };
   void base::fun3(){};
   void (base::* p1)()=&base::fun1;
   void (base::* p2)()=&base::fun2;
   void (base::* p3)()=&base::fun3;
   What are values of p1,p2, and p3?
   p1=1, p2=5, p3=some memory address. In fact, p1 and p2 are indexes of the virtual table of
   class base, which correspond to virtual two functions.
8. Difference between reference and pointer.
   Reference should be initialized in its definition.
   The object referenced to by a reference can't be changed.
   Reference would never be null.
9. Virtual functions, Overload, Override and Hide.
   class base
   {
       public:
           virtual void f(int);
           virtual void f(double);
           virtual void g(int i=10);
   };
   class derived: public base
   {
       public:
           void f(complex<double>);
           void g(int i=20);
   };
   int main()
   {
       base b;
       derived d;
       base *pb=new derived;
       b.f(1.0);  \\ base::f(double);
       d.f(1.0);   \\ derived::f(complex<double>)
                       \\derived::f is a hide instead of overload.
                        \\ Need declaration using base::f(int/double) to call f in base.
                         \\ void base::f(double) will lead to override.
       pb->f(1.0);  \\ base::f(double). It is not overridden in derived.
       b.g();        \\ base::g(10).
       d.g();        \\derived::g(20).
       pb->g();    \\ derived::g(10).  Polymorphism.
       delete pb;   \\ ~derived() would never be called. Error!
       return 0;
   }