某易

[编程题] 瞌睡

小易觉得高数课太无聊了，决定睡觉。不过他对课上的一些内容挺感兴趣，所以希望你在老师讲到有趣的部分的时候叫醒他一下。你知道了小易对一堂课每分钟知识点的感兴趣程度，并以分数量化，以及他在这堂课上每分钟是否会睡着，你可以叫醒他一次，这会使得他在接下来的k分钟内保持清醒。你需要选择一种方案最大化小易这堂课听到的知识点分值。

输入描述:

第一行 n, k (1 <= n, k <= 105) ，表示这堂课持续多少分钟，以及叫醒小易一次使他能够保持清醒的时间。
第二行 n 个数，a1, a2, ... , an(1 <= ai <= 104) 表示小易对每分钟知识点的感兴趣评分。
第三行 n 个数，t1, t2, ... , tn 表示每分钟小易是否清醒, 1表示清醒。

输出描述:

小易这堂课听到的知识点的最大兴趣值。

输入例子1:

6 3
1 3 5 2 5 4
1 1 0 1 0 0

输出例子1:

16

import java.util.*;


public class Main {
   public static void main(String[] args) 
   {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int k=sc.nextInt();
        int[] mark=new int[n];
        long[] max=new long[n];
        short[] iswake=new short[n];
        for (int i = 0; i < mark.length; i++) {
            mark[i]=sc.nextInt();
        }
        for (int i = 0; i < mark.length; i++) {
            iswake[i]=sc.nextShort();
         }
        long fix=0;
        for (int i = 0; i < iswake.length; i++) {
            if (iswake[i]==1) {
                fix=fix+mark[i];
                mark[i]=0;//将加过的兴趣值的改成0
            }
        }
        for (int i = 0; i < n; i++) {
            max[i]=fix;
        }
        for (int i = 0; i < iswake.length; i++) {
            if (iswake[i]==0) {
                if (i+k>n) {
                    for (int j = i; j < n; j++) {
                    
                        max[i]=max[i]+mark[j];
                    }
                    break;//后面的肯定小于第一个故不需要继续计算
                    
                }else {
                    for (int j = i; j < i+k; j++) {
                        
                        max[i]=max[i]+mark[j];
                    }
                }
                
            }
            
        }
        
        Arrays.sort(max);
        System.out.println(max[max.length-1]);
      
    }

}
 
 

 回文字符串

回文字符串，指的是形式如同"abcba"或是"abccba“形式的字符串。

那么如何在一串给定的字符串中寻找其中最长的回文子串呢？

package uestc;

public class Main {

            public static void main(String[] args) {
                String s = "xccxbdc";
                String solu = longestPalindrome1(s);
                System.out.println(solu);

            }
            public static String longestPalindrome(String s) {
                int len = s.length();
                int maxLen = 0;
                String res = null;
                boolean[][] dp = new boolean[len][len];
                for(int i = len - 1;i >= 0;i--){
                    for(int j = i;j < len;j++){
                        dp[i][j] = s.charAt(i) == s.charAt(j) && (j - i < 3 || dp[i+1][j-1] == true);
                        //（1）当前遍历到的子串i~j是否是回文子串取决于i+1~j-1，也就是i~j中间的子串是否是回文并且s[i]是否等于s[j]；
                        //（2）dp[i][j]是为true则意味着i~j是回文子串，则在下面判断后对res进行更新；如果为false，则该子串不是回文子串，开始遍历下一个子串。
                        if(dp[i][j] == true && (res == null || j - i + 1 > maxLen)){
                            //如果该子串长度更长，则更新res
                            res = s.substring(i, j+1);
                            maxLen = res.length();
                        }
                    }
                }
           
                return res;
            }
            private static int start;
            private static int maxLength;    
            public static String longestPalindrome1(String s) //这是
            {        
                if(s.length()<2)            
                      return s;        
                for(int i=0;i<s.length()-1;i++)
                {       //遍历整个数组，寻找回文子串最中间的字符，如果回文子串是奇数长度，那么最中间有一个字符；否则有两个字符
                         extendPali(s,i,i);
                        
                         extendPali(s,i,i+1);    
                        
                }   
                return s.substring(start,start+maxLength);    
                     
            }   
            public static void extendPali(String s,int i,int j)
            {     
                while(i>=0&&j<s.length()&&s.charAt(i)==s.charAt(j))
                {            
                              i--;  //如果满足括号里的条件，则继续向两边扩展        
                              j++;       
                }       
                if(maxLength<j-i-1){ //更新最大长度的值           
                    start=i+1;            
                    maxLength=j-i-1;        
                }  
            }
           }