算法

动态规划

矩阵的总路径数

题目描述：统计从矩阵左上角到右下角的路径总数，每次只能向右或者向下移动。

思路：

我们可以把棋盘的左下角看做二维坐标的原点(0,0)，把棋盘的右上角看做二维坐标(M,N)(坐标系的单位长度为小方格的变长)   

用f(i,j)表示移动到坐标f(i,j)的走法总数，其中0=<i,j<=n，设f(m,n)代表从坐标（0,0）到坐标（m,n）的移动方法，则

f(m,n)=f(m-1,n)+f(m,n-1).

int process(int m, int n) {
    if (m == 0 && n == 0)
        return 0;
    if (m==0 || n==0)
        return 1;
    return process(m, n - 1) + process(m - 1, n);
}

矩阵的最小路径和

思路：求出到达每一个结点map[i][j]的最小路径将其保存在数组dp[i][j]中，求任意dp[i][j]的值完全依赖于dp[i-1][j]和dp[i][j-1]，因此先求出dp[][]数组的第1行和第1列，然后从上到下，从左到右计算出每一个位置的结果值。

①创建一个二维数组记录每个位置的最小路径dp[n][m];

②求出dp[][]中第1行和第1列的结果填充到dp[][]中；注意：在动态规划问题中第1行和第1列需要手动求出，需要根据问题的要求进行求解，一般第1行和第1列的求解很简单。

③从上到下，从左到右，通过二重循环求出任意dp[i][j]的结果填充到dp[][]中；注意：二重循环中i,j都是从1开始进行遍历，即从矩阵第2行第2列的位置开始填充。

④最后dp[n-1][m-1]就是所求的结果。

import java.util.*;
//矩阵最短路径和问题：动态规划4部曲
public class MinimumPath {
    public int getMin(int[][] map, int n, int m) {
        //特殊输入
        if(map==null||n<=0||m<=0) return 0;
        //①创建动态规划结果矩阵dp[][]
        int[][] dp=new int[n][m];
        //②求解第1行第1列的结果值
        dp[0][0]=map[0][0];
        for(int i=1;i<m;i++){
            dp[0][i]=dp[0][i-1]+map[0][i];
        }
        //求第1列的结果值
        for(int i=1;i<n;i++){
            dp[i][0]=dp[i-1][0]+map[i][0];
        }
        //③从上到下，从左到右求任意dp[i][j]
        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                dp[i][j]=map[i][j]+Math.min(dp[i-1][j],dp[i][j-1]);
            }
        }
        //④返回右下角的结果值
        return dp[n-1][m-1];
    }
}

 连续子数组的最大和

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
    if(array.length == 0) return 0;
        int sum = array[0];
        int tempsum = array[0];
        for(int i = 1;i<array.length;i++){
            tempsum = (tempsum<0)?array[i]:tempsum + array[i];
            sum = (tempsum > sum) ? tempsum : sum;
    }
    return sum;
    }
}

 

好未来笔试题

1.对于正整数数组，求最大元素和，要求元素大小必须是升序的。

int [] data = {5,3,1,4,9,7,6,8}

最大升序序列是：1,3,4,7,8

贪心算法

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<Integer> input = new ArrayList<Integer>();
        while (sc.hasNext()) {
            input.add(sc.nextInt());
        }

        if (input.size() == 0) {
            System.out.println(0);
            return;
        }
        if (input.size() == 1) {
            System.out.println(input.get(0));
            return;
        }
        int[] arr = new int[input.size()];
        for (int i = 0; i < input.size(); i++) {
            arr[i] = input.get(i);
        }
        input = null;
        int res = len(arr, arr.length);

        System.out.println(res);
    }

    public static int len(int[] arr, int n) {
        int i, j, max = 0;
        int msis[] = new int[n];
        for (i = 0; i < n; i++) {
            msis[i] = arr[i];
        }
        for (i = 1; i < n; i++) {
            for (j = 0; j < i; j++) {
                if (arr[i] > arr[j] && msis[i] < msis[j] + arr[i])
                    msis[i] = msis[j] + arr[i];
            }
        }
        for (i = 0; i < n; i++) {
            if (max < msis[i])
                max = msis[i];
        }

        return max;
    }
}

 2.

递归方法：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int [] a = new int [10];
        for(int i= 0;i<10;i++){
            a[i] = sc.nextInt();
        }
        String s = new String();
        getNumber(a,0,s);
        Collections.sort(al);

        for(String ss : al){
            System.out.println(ss);
        }
    }

    public static ArrayList<String> al = new  ArrayList<>();
    public static void getNumber(int [] a,int index,String s){
        if(index == 10){
            al.add(s);
            return;
        }
        if(a[index] == 0){
            getNumber(a,index+1,s);
            s = s+""+index;
            getNumber(a,index+1,s);
        }else {
            s = s+""+index;
            getNumber(a,index+1,s);
        }
    }
}

3.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

/**
 * Created by dp on 2018/8/28.
 */
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String str = bufferedReader.readLine();
        int indexStart = str.length()-1;
        int res = 0;
        int indexEnd = indexStart;
        while (indexStart>=0){
            String te = str.substring(indexStart,indexEnd+1);
            if(ifCan(te)){
                res++;
                indexStart--;
                indexEnd = indexStart;
                continue;
            }else {
                indexStart--;
                continue;
            }
        }
        System.out.println(res);
    }
    public static boolean ifCan(String str){
        int temp = Integer.parseInt(str);
        if(temp%3 == 0){
            return true;
        }else
            return false;
    }
}