leetcode的一些题解

　　进入护网行动，各项开发暂缓。闲暇刷了一些leetcode的题，记录了一些有意思的。

题目描述
设有n个正整数，将他们连接成一排，组成一个最大的多位整数。
如:n=3时，3个整数13,312,343,连成的最大整数为34331213。
如:n=4时,4个整数7,13,4,246连接成的最大整数为7424613。
输入描述:
有多组测试样例，每组测试样例包含两行，第一行为一个整数N（N<=100），第二行包含N个数(每个数不超过1000，空格分开)。
输出描述:
每组数据输出一个表示最大的整数。
示例1
输入

2
12 123
4
7 13 4 246
输出

12312
7424613

 

 

import java.util.*;
public class Main
{
public static String compareString(String str1,String str2)
{ int num1=Integer.parseInt(str1+str2);
int num2=Integer.parseInt(str2+str1);
if(num1>num2)return str1;
else if(num1<num2)return str2;
else return str1;

}
public static boolean isBigger(String str1,String str2)
{
int num1=Integer.parseInt(str1+str2);
int num2=Integer.parseInt(str2+str1);
if(num1>num2)return true;
return false;
}
public static void main(String[] args)
{
Scanner scan=new Scanner(System.in);
ArrayList<String> resultList=new ArrayList<String>();
//读取数据
while(scan.hasNext()){
int N=0;

N=scan.nextInt();
String[] nums=new String[N];
String sum="";

for(int i=0;i<N;i++)
{
nums[i]=String.valueOf(scan.nextInt());
}
//排序算法
for(int i=0;i<N;i++){
for(int j=i+1;j<N;j++)
{
if(isBigger(nums[j],nums[i]))
{
String t=nums[i];
nums[i]=nums[j];
nums[j]=t;
}
}
}
for(int i=0;i<N;i++)
{sum=sum+nums[i];
}
resultList.add(sum);
}

//输出结果
for(int i=0;i<resultList.size();i++)
System.out.println(resultList.get(i));


}



}

 

 

 

 

-----------------------------------2-------------------------------------------

题目描述
某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。

输入描述:
每组输入有两行，
第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），
第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。
输出描述:
每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。

 

package javacode;

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

public class Main{

public static void main(String args[]){

int N=22;

int sum=0;
//int a[]={98 51 21 93 38 65 41 46 9 58 36 77 51 62 92 1 28 84 45 88 10 75};


Scanner scan=new Scanner(System.in);
N=scan.nextInt();
int a[]=new int[N];
int max[]=new int[N];
for(int i=0;i<N;i++)
{
a[i]=scan.nextInt();
}
max[N-1]=1;
for(int i=N-2;i>=0;i--){
//找出比其小的数字
List poslist=new ArrayList();
int maxsize=0;
for(int j=i+1;j<N;j++)
{
if(a[i]>=a[j])poslist.add(j);
}
if(poslist.isEmpty())max[i]=1;
else{
//有比其小的数
for(int k=0;k<poslist.size();k++)
{
if(maxsize<max[(int) poslist.get(k)])maxsize=max[(int) poslist.get(k)];
}
max[i]=maxsize+1;
}


}
sum=max[0];
for(int i=0;i<N-1;i++)
{
if(max[i]>sum)sum=max[i];
}
System.out.println(sum);
}
}

 

 

 

 

 

 

 

 

---------------------------------------------------------5---------------
class Solution {
public String longestPalindrome(String s) {
String result="";
for(int i=s.length();i>0;i--)
{
for(int j=0;j+i<=s.length();j++)
{
String temp=s.substring(j,j+i);
if(isPalindrome(temp)){result=temp;return result;}
}
}
return result;
}


public boolean isPalindrome(String s){
int i=0;int j=s.length()-1;
while(j>=i){

if(s.charAt(i)!=s.charAt(j))return false;
i++;j--;
}
return true;

}
}

 

 

 

 

 

遍历----超出 时间 限制
class Solution {
public String longestPalindrome(String s) {
String result="";
for(int i=0;i<s.length();i++)
{
for(int j=s.length();j>i;j--)
{
String temp=s.substring(i,j);
if(isPalindrome(temp)&&temp.length()>result.length()){result=temp;}
}
}
return result;
}


public boolean isPalindrome(String s){
int i=0;int j=s.length()-1;
while(j>=i){

if(s.charAt(i)!=s.charAt(j))return false;
i++;j--;
}
return true;

}
}

 

 

-----------------------------10、正则表达式 匹配

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。

'.' 匹配任意单个字符
'*' 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

说明:

s 可能为空，且只包含从 a-z 的小写字母。
p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。
示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:

输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3:

输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
示例 4:

输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
示例 5:

输入:
s = "mississippi"
p = "mis*is*p*."
输出: false

 

//回溯法
class Solution {
public boolean isMatch(String s, String p) {
//--init
Stack st1=new Stack();
Stack st2=new Stack();


for(int i=0;i<s.length();i++)
st1.push(""+s.charAt(i));
char next='1';
for(int i=0;i<p.length();i++)
{
char temp=p.charAt(i);
if(p.length()>(i+1))next=p.charAt(i+1);
if(next=='*'){st2.push(""+temp+next);i++;next='1';}
else {st2.push(""+temp);}
}
return doMatch(st1,st2);


}



public boolean doMatch(Stack st1,Stack st2){
if(st1.empty()&&st2.empty())return true;
if(st2.empty()&&!st1.empty())return false;
String pat=(String) st2.lastElement();String str=null;
if(!st1.empty())str=(String) st1.lastElement();
if(pat.contains("*")) {
//if-match
if(st1.empty()){st2.pop();return doMatch(st1,st2);}
if(!str.isEmpty()&&pat.charAt(0)==str.charAt(0)||pat.charAt(0)=='.'){
Stack st3=new Stack();st3.addAll(st2); st2.pop();
Stack st0=new Stack();st0.addAll(st1); st1.pop();
return doMatch(st0,st2)||doMatch(st1,st3);
}
else //if-not-match
{ st2.pop();
return doMatch(st1,st2);}
}
else {
if(st1.empty())return false;
if(pat.equals(str)||pat.equals(".")){st1.pop();st2.pop();return doMatch(st1,st2);}
else return false;
}
}
}

转载于:https://www.cnblogs.com/Oneby1/p/11050029.html