分治算法
一、基本概念
在計算機科學中,分治法是一種很重要的算法。字面上的解釋是“分而治之”,就是把一個複雜的問題分成兩個或更多的相同或相似的子問題,再把子問題分成更小的子問題……直到最後子問題可以簡單的直接求解,原問題的解即子問題的解的合併。這個技巧是很多高效算法的基礎,如排序算法(快速排序,歸併排序),傅立葉變換(快速傅立葉變換)……
任何一個可以用計算機求解的問題所需的計算時間都與其規模有關。問題的規模越小,越容易直接求解,解題所需的計算時間也越少。例如,對於n個元素的排序問題,當n=1時,不需任何計算。n=2時,只要作一次比較即可排好序。n=3時只要作3次比較即可,…。而當n較大時,問題就不那麼容易處理了。要想直接解決一個規模較大的問題,有時是相當困難的。
二、基本思想及策略
分治法的設計思想是:將一個難以直接解決的大問題,分割成一些規模較小的相同問題,以便各個擊破,分而治之。
分治策略是:對於一個規模爲n的問題,若該問題可以容易地解決(比如說規模n較小)則直接解決,否則將其分解爲k個規模較小的子問題,這些子問題互相獨立且與原問題形式相同,遞歸地解這些子問題,然後將各子問題的解合併得到原問題的解。這種算法設計策略叫做分治法。
如果原問題可分割成k個子問題,1<k≤n,且這些子問題都可解並可利用這些子問題的解求出原問題的解,那麼這種分治法就是可行的。由分治法產生的子問題往往是原問題的較小模式,這就爲使用遞歸技術提供了方便。在這種情況下,反覆應用分治手段,可以使子問題與原問題類型一致而其規模卻不斷縮小,最終使子問題縮小到很容易直接求出其解。這自然導致遞歸過程的產生。分治與遞歸像一對孿生兄弟,經常同時應用在算法設計之中,並由此產生許多高效算法。
三、分治法適用的情況
分治法所能解決的問題一般具有以下幾個特徵:
1) 該問題的規模縮小到一定的程度就可以容易地解決
2) 該問題可以分解爲若干個規模較小的相同問題,即該問題具有最優子結構性質。
3) 利用該問題分解出的子問題的解可以合併爲該問題的解;
4) 該問題所分解出的各個子問題是相互獨立的,即子問題之間不包含公共的子子問題。
第一條特徵是絕大多數問題都可以滿足的,因爲問題的計算複雜性一般是隨着問題規模的增加而增加;
第二條特徵是應用分治法的前提它也是大多數問題可以滿足的,此特徵反映了遞歸思想的應用;、
第三條特徵是關鍵,能否利用分治法完全取決於問題是否具有第三條特徵,如果具備了第一條和第二條特徵,而不具備第三條特徵,則可以考慮用貪心法或動態規劃法。
第四條特徵涉及到分治法的效率,如果各子問題是不獨立的則分治法要做許多不必要的工作,重複地解公共的子問題,此時雖然可用分治法,但一般用動態規劃法較好。
四、分治法的基本步驟
分治法在每一層遞歸上都有三個步驟:
step1 分解:將原問題分解爲若干個規模較小,相互獨立,與原問題形式相同的子問題;
step2 解決:若子問題規模較小而容易被解決則直接解,否則遞歸地解各個子問題
step3 合併:將各個子問題的解合併爲原問題的解。
它的一般的算法設計模式如下:
Divide-and-Conquer(P)
1. if |P|≤n0
2. then return(ADHOC(P))
3. 將P分解爲較小的子問題 P1 ,P2 ,...,Pk
4. for i←1 to k
5. do yi ← Divide-and-Conquer(Pi) △ 遞歸解決Pi
6. T ← MERGE(y1,y2,...,yk) △ 合併子問題
7. return(T)
其中|P|表示問題P的規模;n0爲一閾值,表示當問題P的規模不超過n0時,問題已容易直接解出,不必再繼續分解。ADHOC(P)是該分治法中的基本子算法,用於直接解小規模的問題P。因此,當P的規模不超過n0時直接用算法ADHOC(P)求解。算法MERGE(y1,y2,...,yk)是該分治法中的合併子算法,用於將P的子問題P1 ,P2 ,...,Pk的相應的解y1,y2,...,yk合併爲P的解。
五、分治法的複雜性分析
一個分治法將規模爲n的問題分成k個規模爲n/m的子問題去解。設分解閥值n0=1,且adhoc解規模爲1的問題耗費1個單位時間。再設將原問題分解爲k個子問題以及用merge將k個子問題的解合併爲原問題的解需用f(n)個單位時間。用T(n)表示該分治法解規模爲|P|=n的問題所需的計算時間,則有:
T(n)= k T(n/m)+f(n)
通過迭代法求得方程的解:
遞歸方程及其解只給出n等於m的方冪時T(n)的值,但是如果認爲T(n)足夠平滑,那麼由n等於m的方冪時T(n)的值可以估計T(n)的增長速度。通常假定T(n)是單調上升的,從而當 mi≤n<mi+1時,T(mi)≤T(n)<T(mi+1)。
(8)最接近點對問題
HDU1402
A * B Problem Plus
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 9856 Accepted Submission(s): 1626
Note: the length of each integer will not exceed 50000.
import java.io.*;
import java.util.*;
class FFT{
final double PI=Math.acos(-1.0);
class Complex{
public double r,i;
public Complex(double r,double i){
this.r=r; this.i=i;
}
public Complex add(Complex c){
return new Complex(r+c.r, i+c.i);
}
public Complex sub(Complex c){
return new Complex(r-c.r, i-c.i);
}
public Complex mul(Complex c){
return new Complex(r*c.r-i*c.i, r*c.i+i*c.r);
}
}
Complex[] fft(Complex[] a, double alpha){ //折半的是係數a的長度
int n=a.length;
if( n==1 ) {
return a;
}
Complex[] a0=new Complex[n/2];
for(int i=0;i<n;i+=2) {
a0[i/2]=new Complex(a[i].r, a[i].i);
}
Complex[] a1=new Complex[n/2];
for(int i=1;i<n;i+=2) {
a1[i/2]=new Complex(a[i].r, a[i].i);
}
Complex[] y0=fft(a0, alpha);
Complex[] y1=fft(a1, alpha);
Complex wn=new Complex(Math.cos(alpha*2*PI/n), Math.sin(alpha*2*PI/n));
Complex w=new Complex(1.0, 0), tmp;
Complex[] y=new Complex[n];
for(int i=0;i<n/2;i++){
tmp=w.mul(y1[i]);
y[i]=y0[i].add(tmp);
y[i+n/2]=y0[i].sub(tmp);
w=w.mul(wn);
}
return y;
}
Complex[] toComplex(int[] a, int s){
Complex[] ret=new Complex[s];
for(int i=0;i<ret.length;i++){
if( i<a.length) {
ret[i]=new Complex((double)a[i], 0.0);
}
else {
ret[i]=new Complex(0.0, 0.0);
}
}
return ret;
}
long[] polyMultiply(int[] c0,int[] c1){
int s=1;
while( s<c0.length+c1.length ) {
s<<=1;
}
Complex[] a0=toComplex(c0, s);
Complex[] a1=toComplex(c1, s);
Complex[] y0=fft(a0, 1.0);
Complex[] y1=fft(a1, 1.0);
for(int i=0;i<y0.length;i++) {
y0[i]=y0[i].mul(y1[i]);
}
Complex[] a=fft(y0, -1.0);
for(int i=0;i<a.length;i++) {
a[i].r/=s; a[i].i/=s;
}
long[] c=new long[s];
//System.out.println("debug:\n");for(int i=0;i<s;i++) System.out.printf("%.5f ",a[i].r); System.out.println();
for(int i=0;i<c.length;i++) {
c[i]=(long)(a[i].r+0.5);
}
//System.out.println("debug:\n");for(int i=0;i<s;i++) System.out.printf("%d ",c[i]); System.out.println();
return c;
}
}
class FastMul{
final int SIZE=3;
final int BASE=1000;
int[] toIntArray(String a){
int[] ret=new int[a.length()/SIZE+1];
for(int e=0, i=a.length()-SIZE;i>-SIZE;i-=SIZE){
int val=0;
for(int j=i;j<i+SIZE;j++) {
if( j>=0 ) {
val=10*val+a.charAt(j)-'0';
}
}
ret[e++]=val;
}
return ret;
}
public long[] mul(String a,String b){
int[] c0=toIntArray(a);
int[] c1=toIntArray(b);
FFT f=new FFT();
long[] res=f.polyMultiply(c0, c1);
long c=0;
for(int i=0;i<res.length;i++){
c+=res[i]; res[i]=(int)(c%BASE); c/=BASE;
}
int i=res.length-1;
while( i>0 && res[i]==0 ) {
i--;
}
System.out.printf("%d", res[i--]);
while( i>=0 ) {
System.out.printf("%03d", (int)res[i--]);
}
System.out.println();
return res;
}
}
public class a1402{
void test(){
FastMul f=new FastMul();
Scanner cin=new Scanner(new BufferedReader( new InputStreamReader(System.in) ));
while( cin.hasNext() ){
String a,b;
a=cin.next();
b=cin.next();
f.mul(a, b);
//BigInteger A=new BigInteger(a);
// BigInteger B=new BigInteger(b);
//System.out.println(A.multiply(B));
}
}
public static void main(String[] args){
a1402 a=new a1402();
a.test();
}
}