牛客NC183 最长公共子数组【中等 动态规划 提供Java,Go,PHP答案】

题目

题目链接：
https://www.nowcoder.com/practice/6032826d387c4a10ad3690cce5fdb015

思考

	最长公共子数组通常考虑以每一个元素为结尾的情况下的长度，取最大

参考答案Java

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param A int整型一维数组
     * @param B int整型一维数组
     * @return int整型
     */
    public int longestCommonSubarry (int[] A, int[] B) {
        // 动态规划，最长公共子数组，最长公共子串等都可以用本答案，稍做修改就可以
        int n = A.length;
        int m = B.length;

        int[][] dp = new int[n][m];
        int max = 0, endIndex = -1;

        for (int i = 0; i < n ; i++) {
            for (int j = 0; j < m ; j++) {
                if (A[i] == B[j]) {
                    if (i == 0 || j == 0) {
                        dp[i][j] = 1;
                    } else {
                        dp[i][j] = dp[i - 1][j - 1] + 1;
                    }
                    if (dp[i][j] > max) {
                        max = dp[i][j];
                        endIndex = i;
                    }
                }
            }
        }

        //本答案也包含最长公共子数组是谁，endIndex就是子数组的最后一个位置
        return max;
    }
}

参考答案Go

package main


/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param A int整型一维数组 
 * @param B int整型一维数组 
 * @return int整型
*/
func longestCommonSubarry( A []int ,  B []int ) int {
   //动态规划
	//最长公共子串、子串的长度、子数组、子数组的长度等都可以用本答案稍加修改就可以
	n := len(A)
	m := len(B)

	dp := make([][]int, n)
	for i := 0; i < n; i++ {
		dp[i] = make([]int, m)
	}

	ans := 0
	//endIndex := -1 //本题不需要这个，但是如果求具体最长的公共子数组、子串就能用到这个变量

	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			if A[i] == B[j] {
				if i == 0 || j == 0 {
					dp[i][j] = 1
				} else {
					dp[i][j] = dp[i-1][j-1] + 1
				}

				if ans < dp[i][j] {
					ans = dp[i][j]
					//	endIndex = i
				}
			}
		}
	}

	//fmt.Println(endIndex)
	return ans
}

参考答案PHP

<?php


/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param A int整型一维数组 
 * @param B int整型一维数组 
 * @return int整型
 */
function longestCommonSubarry( $A ,  $B )
{
    //动态规划
    //最长公共子串，子数组 及其对应长度都可以用答案，稍加修改就可以
    $n = count($A);
    $m = count($B);
    $max = 0;

    $dp = [];
    for ($i = 0; $i < $n; $i++) {
        for ($j = 0; $j < $m; $j++) {
            $dp[$i][$j] = 0;
        }
    }

    $endIndex = -1; //求具体最长公共子串，子数组能用到
    for ($i = 0; $i < $n; $i++) {
        for ($j = 0; $j < $m; $j++) {
            if ($A[$i] == $B[$j]) {
                if ($i == 0 || $j == 0) {
                    $dp[$i][$j] = 1;
                } else {
                    $dp[$i][$j] = $dp[$i - 1][$j - 1] + 1;
                }

                if ($max < $dp[$i][$j]) {
                    $max = $dp[$i][$j];
                    $endIndex = $i;
                }
            }
        }
    }
    return $max;
}