分治法、回溯法、贪心法等等算法

1.分治法：最大子段和的问题

分治法：就是将一个大问题，划分为很多小问题，再逐个解决小问题，最后合并结果。并且子问题间互相独立。（跟递归是亲兄弟，实现方法就是递归法。）

package test;

public class Main {
    //最大子段和的问题。
    public static void main(String[] args) {
        int []input=new int[]{1,-1,3,5,9,-10,5,10,-10};
        int low=0;
        int high=input.length-1;
        System.out.println(maxSubSum(input,low,high));
    }

    public static int maxSubSum(int[]Array,int low,int high){
        int sum=0;
        if(low==high){   //仅有一个元素，递归退出
            if(Array[low]>0)
                sum=Array[low];
        }
        else{
            int mid=(low+high)/2;
            int leftMax=maxSubSum(Array,low,mid);
            int rightMax=maxSubSum(Array,mid+1,high);
            int lefts=0;
            int rights=0;
            sum=0;
            for(int i=mid;i>=low;i--){
                sum+=Array[i];
                if(sum>lefts){
                    lefts=sum;
                }
            }
            sum=0;
            for(int i=mid+1;i<=high;i++){
                sum+=Array[i];
                if(sum>rights){
                    rights=sum;
                }
            }
            sum=lefts+rights;
            if(sum<leftMax){
                sum=leftMax;
            }
            if(sum<rightMax){
                sum=rightMax;
            }
        }
        return sum;
    }
}

2.回溯法:8皇后问题。

package test;

import javax.swing.*;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //N皇后问题;
        Scanner in=new Scanner(System.in);
        int N=in.nextInt();
        int count=N_Queue(N);
        System.out.println(N+"皇后共有"+count+"种摆法");
    }

    public static int Judge(int []Column_Num,int index){   //判断是否冲突，冲突是返回1,否则返回0。
        int result=0;
        for(int i=1;i<index;i++){
            if(Column_Num[i]==Column_Num[index]||Math.abs(i-index)==Math.abs(Column_Num[i]-Column_Num[index])){
                result=1;
                break;
            }
        }
        return result;
    }

    public static int N_Queue(int N){
        int count=0;
        int []Column_Num=new int[N+1];
        for(int i=1;i<=N;i++){
            Column_Num[i]=0;
        }
        int index=1;
        while(index>0){
            Column_Num[index]++;
            while(Column_Num[index]<=N&& Judge(Column_Num,index)==1) Column_Num[index]++;
            if(Column_Num[index]<=N){
                if(index==N){
                    count++;
                    Column_Num[index]=0;
                    index--;
                }
                else{
                    index++;
                }
            }
            else{
                Column_Num[index]=0;
                index--;
            }
        }
        return count;
    }
}