网易2017内推笔试题

//有 n 个学生站成一排，每个学生有一个能力值，牛牛想从这 n 个学生中按照顺序选取 k 名
//学生，要求相邻两个学生的位置编号的差不超过 d，使得这 k 个学生的能力值的乘积最大，
//你能返回最大的乘积吗？
//错误解：（没有将d放进去，，，怎么将d考虑）因为你要已知一个放的位置，再找第二个的时候
//你就必须在d范围之内。
public class Main{
    int f[][];
       int g[][];
    public static void main(String []args)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int capacity []=new int[n];
        for(int i=0;i<n;i++)
        {
            capacity[i]=sc.nextInt();
        }
        int k=sc.nextInt();
        int d=sc.nextInt();

       f=new int[n+1][k+1];
       g=new int[n+1][k+1];

        for(int i=0;i<f.length;i++)
        {
            if(i==0)
            {
               Arrays.fill(f[i],0); 
            }
            else
            {
              Arrays.fill(f[i],Integer.MIN_VALUE);  
            }

        }
        for(int j=0;j<d.length;j++)
        {
            if(j==0)
            {
                Arrays.fill(g[j],0);
            }
            else
            {
                Arrays.fill(g[j],Integer.MIN_VALUE);
            }

        }

        f[1,1]=capacity[i];


        return maxValue(n,k);






    }
    public static maxValue(int n,int k,int a[])
    {
        if(f[k][d]!=Integer.MIN_VALUE)
        {
            return f[n][k];
        }
        else
        {
                int x1=maxValue(n-1,k-1,a)*a[n-1];
                int x2=maxValue(n-1,k,a);
                int x3=minValue(n-1,k-1,a)*a[n-1];
                int max=Math.max(x1,x2);
                max=Math.max(max,x3);            

                f[n][k]=max;

                return max;
        }


    }

    public static minValue(int n,int k,int a[])
    {
        if(g[n][k]!=Integer.MIN_VALUE)
        {
            return g[n][k];
        }
        else
        {
            int x1=minValue(n-1,k-1,a)*a[n-1];
            int x2=maxValue(n-1,k-1,a)*a[n-1];
            int x3=minValue(n-1,k,a);
            int min=Math.min(x1,x2);
            min=Math.min(min,x3);
            g[n][k]=min;
            return min;
        }
    }

}

//////////////////////////调试了好久的代码，测试用例不通过，只是因为数组越界要用long
import java.util.*;
public class Main{

    public static void main(String []args)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int capacity []=new int[n+1];
        for(int i=1;i<=n;i++)
        {
            capacity[i]=sc.nextInt();
        }
        int k=sc.nextInt();
        int d=sc.nextInt();

       long f[][]=new long[n+1][k+1];
       long g[][]=new long[n+1][k+1];

        long max=Integer.MIN_VALUE;
        for(int i=1;i<=n;i++)
        {

            f[i][1]=capacity[i];
             g[i][1]=capacity[i];
            for(int j=2;j<=k;j++)
            {
                f[i][j]=Integer.MIN_VALUE;
                g[i][j]=Integer.MAX_VALUE;
             for(int left=i-1;left>=0&&left>=i-d;left--)
             {
                f[i][j]=Math.max(f[i][j],Math.max(f[left][j-1]*capacity[i],g[left][j-1]*capacity[i]));
                g[i][j]=Math.min(g[i][j],Math.min(f[left][j-1]*capacity[i],g[left][j-1]*capacity[i]));
             }

            }

            max=Math.max(max,f[i][k]);
        }       


        System.out.println(max);









    }



}