目录
编码问题 (JAVA)
例如：N=6时，有： A=（4，3，0，5，1，2）
此时，数组A的编码定义如下：
A[0]的编码为0；
A[i]的编码为：在A[0]，A[1]，……A[i-1]中比A[i]的值小的个数（i=1，2……N-1）
∴上面数组A的编码为： B=（0，0，0，3，1，2）
程序要求解决以下问题：
① 给出数组A后，求出其编码；
② 给出数组A的编码后，求出A中的原数据。
输入
第一行是一个字母A或者B,分别表示给出的是A数组或者是B数组的值
第二行给出的是N
第三行给出的是数组A或者B的元素的值
输出
输出一行整数，整数之间用空格分开
样例输入
A
6
4 3 0 5 1 2
样例输出
0 0 0 3 1 2
思路：
由A推出B很简单，就不用说了，直接两重循环。
B推A的话：刚开始也是没有思路，后面经过几次举例，发现了方法，以上面的B = {0 0 0 3 1 2}为例
创一个数组P，依次赋值 { 0 1 2 3 4 5 };
从B的后面开始，取P数组里面索引为 2 的数，就是 2 咯
所以B数组最后一位对应的数为 2 ；
再把P数组里面的2删去，P = { 0 1 3 4 5 };
接着看倒数第二个 取P数组里面索引为 1 的数，就是 1 ，删去P中对应的数，P = { 0 3 4 5 };
再取P数组里面索引为 3 的数，就是 5 ，P = { 0 3 4 };
取P数组里面索引为 0 的数，就是 0 ，P = { 3 4 };
取P数组里面索引为 0 的数，就是 3 ，P = { 4 };
最后一个 就是 4啦。
所以我想到了用ArrayList集合来实现，它的get方法可以得到给出索引的值
remove方法可以删除给出索引的值。。刚好是我想要的。
import java.util.*;
public class text {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String a=sc.next();
int b=sc.nextInt();
int p[]=new int[b];
int last[]=new int[b];//用于放值
for(int i=0;i<b;i++){
p[i]=sc.nextInt();
}
//判断需要进行的方法
if(a.equals("A")){
findB(p, last);
}else if(a.equals("B")){
findA(p,last);
}
//打印结果
for(int i:last){
System.out.print(i+" ");
}
}
public static void findB(int p[],int last[]){
int count;last[0]=0;
for(int i=1;i<p.length;i++){
count=0;
for(int j=0;j<i;j++){
if(p[j]<p[i]){
count++;
}
}
last[i]=count;
}
}
public static void findA(int p[],int last[]){
ArrayList<Integer> s = new ArrayList<>();//新建集合
for(int i=0;i<p.length;i++){
s.add(i);//初始化
}
for(int i=p.length-1;i>=0;i--){
last[i]=s.get(p[i]);//得到对应索引的值并赋值；
s.remove(p[i]);//删除对应索引的值；
}
}
}
方阵问题
在一个N*N的方阵中，填入1，2，……N * N个数，并要求构成如下的格式：
例如：
N=5
13 14 15 16 1
12 23 24 17 2
11 22 25 18 3
10 21 20 19 4
观察矩阵的形成，发现相当于矩阵构成类似一个个口字形，从外到内填充，类似于一堵堵“墙”，不断包围。
把每一堵“墙”独立来看，相当于先往下填充，到达边界后往左，往上，往右，这个步骤会重复几遍与输入的n有关，n=1时易知执行一遍，n=2时也执行一遍，n=3时执行2遍，易知重复次数 = （n+1）/2。
于是创建方法addwall，需要的参数是二维数组，起始位置的值，以及该位置的行数和列数，在主函数中使用for循环，根据“墙”的数量调用。
import java.util.*;
import java.util.InputMismatchException;
public class Main {
public static void main(String args[]){
int i,j;
Scanner sc = new Scanner(System.in);
int n = 0; //局部变量需要初始化
try{
n = sc.nextInt();
}catch(InputMismatchException e){
System.out.println("Input data error");
System.exit(0);
}//对于输入非整数的处理
if(n < 1 || n > 50){
System.out.println("Input data error");
System.exit(0);
}
int array[][] = new int[n][n];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
array[i][j] = 0;
}
}//初始化数组为0
array[0][n-1] = 1;//把起始点的值设为1
int num_wall = (n+1)/2;
i = 0;j = 1;
for(;num_wall >0 ;num_wall--){
array = addwall(array,i,n-j,n);
i++;
j++;
//每一堵墙的起始位置的坐标
}
for (i = 0; i < n; i++) {
for (j = 0; j < n-1; j++) {
System.out.print(array[i][j]+" ");
}
System.out.println(array[i][n-1]);
}
}
public static int[][] addwall(int[][] a,int line,int row,int n){
int i=0,j=0;
if(a[line][row]!=1){
a[line][row] = a[line-1][row]+1;//每一堵墙的起始值
}
while(line+1 < n && a[line+1][row] == 0){
a[line+1][row] = a[line][row]+1;//往下走 +1
line = line+1;//更新当前位置
}
while((row-1) >= 0 && a[line][row-1] == 0){
a[line][row-1] = a[line][row]+1;//往左走 +1
row = row-1;
}
while((line-1) >= 0 &&a[line-1][row] == 0 ){
a[line-1][row] =a[line][row]+1;//往上走 +1
line = line-1;
}
while((row+1) < n && a[line][row+1] == 0 ){
a[line][row+1] =a[line][row]+1;//往右走 +1
row = row+1;
}
return a;
}
}寻找路径
题目描述
二叉树也可以用数组来存储，给定一个数组，树的根节点的值储存在下标1， 对于储存在下标n的节点，他的左子节点和右子节点分别储存在下标2n和2n+1， 并且我们用-1代表一个节点为空。 给定一个数组存储的二叉树，试求从根节点到最小的叶子节点的路径，路径由节点的值组成。
输入
输入一行为数组的内容，数组的每个元素都是正整数，元素间用空格分割。 注意第一个元素即为根节点的值，即数组的第n元素对应下标n。下标0在树的表示中没有使用，所以我们省略了。 输入的树最多为7层。
输出
输出从根节点到最小叶子节点的路径上各个节点的值由空格分割用例保证最小叶子节点只有一个
样例输入 复制
3 5 7 -1 -1 2 4样例输出 复制
3 7 2 public static void main(String[] args) {
//接收输入
Scanner in = new Scanner(System.in);
List<Integer> res = new ArrayList<>();
String[] str = in.nextLine().split(" ");
in.close();
//输入转化到ArrayList里面
for (String s : str) {
res.add(Integer.parseInt(s));}
//输入转化到a数组里面
int[]a=new int[res.size()];
for (int i = 0; i < res.size(); i++) {
a[i]=res.get(i);
}
//清除ArrayList
res.clear();
//判断是不是只有根节点，是就直接输出
int n=a.length;
if(n==1)
{
System.out.print(a[0]);
return;
}
//判断叶子结点数目
int i;
for ( i = 1; ; i=i*2) {
if(n-i>0)continue;
else break;
}
i=i/2;
//由叶子结点数目判断树高
int high= (int) (log(i)/log(2)+1);
//由树高判断是不是满数，如果最后几个叶子结点为空，需要手动添加-1
double num=Math.pow(2,high)-1;
if(num>a.length){
a = Arrays.copyOf(a, (int) num);
for (int j = n; j < a.length; j++) {
a[j]=-1;
}
}
//拿到所有叶子结点，不满的已经补上了
int[] b=new int[i];
for (int j = a.length-i, m=0; m<i ; j++,m++) {
b[m]=a[j];
}
//拿到第一个不是空的叶子结点
int index=0,min=-1;
for (int j = 0; j <b.length ; j++) {
if(b[j]!=-1){index=j;min=b[j];break;}
else continue;
}
//找到最小叶子结点
for (int k = 0; k <b.length ; k++) {
if(b[k]<0)continue;
if(min>b[k]){index=k;min=b[k];}
}
//添加叶子结点和逆向到根节点
res.add(a[index+1+a.length-i-1]);
int index2=a.length-i;
i=i/2;
for (int j = 0; j < high-2; j++) {
index2=index2-i;
i=i/2;
if((index2+(index)/2)<=0){
System.out.print(index2+(index)/2);
return;
}
res.add(a[index2+(index)/2]);
index=(index)/2;
}
res.add(a[0]);
//输出
for (int j = res.size()-1; j >=0; j--) {
System.out.print(res.get(j));
if(j!=0)System.out.print(" ");
}
}链表环路检测
给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。若环不存在，请返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
public static ListNode detectCycle(ListNode head) {
//判断是不是空和是不是只有一个节点
if(head==null||head.next==null)return null;
//记录快慢指针并走一次
ListNode fast=head;
ListNode slow=head;
fast= fast.next.next;
slow=slow.next;
//判断快慢指针能不能走到一起，不能返回空节点
while(fast!=slow){
if(fast==null||fast.next==null)return null;
fast= fast.next.next;
slow=slow.next;
}
//判断环入口还不是头结点
if(fast==head)return fast;
//再走一次
fast=head;
fast= fast.next;
slow=slow.next;
while(fast!=slow){
fast= fast.next;
slow=slow.next;
}
return fast;
}
}有重复全排列
给定一个只包含大写英文字母的字符串S，要求你给出对S重新排列的所有不相同的排列数。
如：S为ABA，则不同的排列有ABA、AAB、BAA三种。
解答要求
时间限制：5000ms, 内存限制：100MB
输入
输入一个长度不超过10的字符串S，确保都是大写的。
输出
输出S重新排列的所有不相同的排列数（包含自己本身）。
样例输入 复制
ABA样例输出 复制
3
import java.util.Scanner;
public class 全排列 {
static int num=0;
public static void main(String[] args) {
String s="";
Scanner scanner=new Scanner(System.in);
s=scanner.nextLine();
char[] chars=s.toCharArray();
sort(chars,0,chars.length);
System.out.print(num);
}
public static boolean charge(char[] chars,int now,int i){
if(now==i) return true;
for (int j = now; j <i ; j++) {
if(chars[j]==chars[i])
return false;
}
return true;
}
public static void sort(char[] chars,int now,int len){
if(now==len-1)num++;
for (int i = now; i <len ; i++) {
if(charge(chars,now,i)) {
swap(chars, now, i);
sort(chars, now + 1, len);
swap(chars, now, i);
}
}
}
public static void swap(char[] chars,int now,int next){
char temp=' ';
temp=chars[now];
chars[now]=chars[next];
chars[next]=temp;
}
}最大报酬
题目描述
小明每周上班都会拿到自己的工作清单，工作清单内包含n项工作，每项工作都有对应的耗时时间（单位h）和报酬, 工作的总报酬为所有已完成工作的报酬之和，那么请你帮小明安排一下工作，保证小明在指定的工作时间内工作收入最大化。
输入
输入的第一行为两个正整数T，n。 T代表工作时长（单位h，0<T<1000000），n代表工作数量（1<n≤3000）。 接下来是n行，每行包含两个整数t，w。 t代表该工作消耗的时长（单位h，t>0）,w代表该项工作的报酬。
输出
输出小明制定工作时长内工作可获得的最大报酬。
样例输入 复制
40 3
20 10
20 20
20 5样例输出 复制
30
import java.util.Scanner;
public class 最大报酬 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner read = new Scanner(System.in);
int T = read.nextInt();
int M = read.nextInt();
int[][] dp = new int[M+1][T+1];
int[] time = new int[M+1];
int[] price = new int[M+1];
for(int i=1;i<=M;i++)
{
time[i] = read.nextInt();
price[i] = read.nextInt();
}
for(int i=1;i<=M;i++)
for(int j=1;j<=T;j++)
{
if(j-time[i]>=0)
{
dp[i][j] =Math.max(dp[i-1][j], dp[i-1][j-time[i]]+price[i]);
}
else
{
dp[i][j] = dp[i-1][j];
}
}
System.out.println(dp[M][T]);
read.close();
}
}爬楼梯
冬冬爬楼梯，一步可以1级，也可以爬2级、3级。冬冬很可爱，每到一处楼梯处，他都想知道直完这个楼梯有多少种走法。但由于有的时候楼梯级数太多，可能是个天文数字，很显然，对于还处于小学5年级的冬冬是不太现实的。聪明的你，能帮冬冬实现这个愿望吗？
输入
多笔测资，每笔测资一行：整数n (1<=n<=3000)
输出
对第笔测资，输出一个整数，为n级楼梯冬冬走完的方法数。
样例输入 复制
1
2
3
样例输出 复制
1
2
4提示
递推
public class dongdong {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int n = in.nextInt();
System.out.println(cout(n));
}
}
public static BigInteger cout(int n) {
BigInteger a =new BigInteger(1+""),b =new BigInteger(2+""),c =new BigInteger(4+"");
if(n==1)return a;
else if(n==2)return b;
else if(n==3)return c;
BigInteger sum =new BigInteger(0+"");
for (int i = 4; i <= n; i++) {
sum = a.add(b).add(c);
a=b;
b=c;
c=sum;
}
return sum;
}
}
只出现一次的数
题目描述
现给你一组数，要求你找出其中只出现过一次的那个数。题目保证只有一个数字出现过一次，并且除了只出现一次的那个数字外，其余的数字均出现了偶数次。
输入
输入包含多组测试样例。每组样例第一行为一个正整数n（1<=n<=1000000，并且n为奇数），表示数字的个数。
接下来的一行为n个正整数，所有的数都小于2^31。
当n=0时，输入结束。
输出
输出只出现过一次的那个数字，每组结果占一行。
样例输入 复制
5
1 1 3 2 2
3
1 2 1
0样例输出 复制
3
2
public class OnlyNumber {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
while(n!=0){
HashMap<Integer,Integer> map=new HashMap<>();
int [] a=new int[n];
for(int i=0;i<n;i++){
a[i]=scanner.nextInt();
if(map.get(a[i])==null) {
map.put(a[i], 1);
}else{
map.put(a[i], 0);
}
}
for(int i=0;i<map.size();i++){
if(map.get(a[i])==1){
System.out.println(a[i]);
break;
}
}
n = scanner.nextInt();
}
}
}层板等分衣柜
题目描述
给定一个高度为2000mm的柜子空间，以及n个层板，给出层板距离柜子底部的高度，请你移动层板放到合适位置，时层板等分衣柜空间，请你帮我计算出移动层板的顺序
层板号自下向上排列，1，2，3，，，n 注意层板不得跨层移动
输入
两行输入 第一行为层板个数 n
第二行为空格隔开的各个层板的位置 从1开始
输出
所有可能的结果，每行为一种情况 如果多行请按照从小到大排序
样例输入 复制
3
50 60 100样例输出 复制
3 2 1
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class slipt {
static ArrayList<ArrayList<Integer>> list=new ArrayList();
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int[] a=new int[n];
for(int i=0;i<n;i++) {
a[i]=scanner.nextInt();
}
boolean[] v=new boolean[n];
fun(a,n,v,new ArrayList());
for(int i=0;i<list.size();i++) {
for(int j=0;j<list.get(i).size();j++) {
System.out.print(list.get(i).get(j)+" ");
}
System.out.println();
}
}
public static void fun(int[] a,int n,boolean[] v,ArrayList<Integer> temp) {
if(temp.size()==n) {
list.add(new ArrayList(temp));
return;
}
for(int i=0;i<n;i++) {
if(v[i]==true) continue;
if(i==0) {if(a[1]<=2000/(n+1)) continue;}
else if(i==n-1) {if(a[n-2]>2000-2000/(n+1)) continue;}
else {if(a[i+1]<(i+1)*(2000/(n+1)) || a[i-1]>(i+1)*(2000/(n+1))) continue;}
v[i]=true;
temp.add(i+1);
int flag=a[i];
a[i]=(i+1)*(2000/(n+1));
fun(a,n,v,temp);
a[i]=flag;
temp.remove(temp.size()-1);
v[i]=false;
}
}
}称砝码
描述
现有一组砝码，重量互不相等，分别为 m1,m2,m3…mn ；
每种砝码对应的数量为 x1,x2,x3…xn 。现在要用这些砝码去称物体的重量(放在同一侧)，问能称出多少种不同的重量。
注：
称重重量包括 0
本题有多组输入
输入描述：
输入包含多组测试数据。
对于每组测试数据：
第一行：n — 砝码数(范围[1,10])
第二行：m1 m2 m3 … mn — 每个砝码的重量(范围[1,2000])
第三行：x1 x2 x3 … xn — 每个砝码的数量(范围[1,6])
输出描述：
利用给定的砝码可以称出的不同的重量数
输入
2
1 2
2 1输出
5
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()) {
int n = in.nextInt(); // 砝码数
int[] weights = new int[n]; // 砝码重量
int[] nums = new int[n]; // 砝码数量
for (int i = 0; i < n; i++) {
weights[i] = in.nextInt();
}
for (int i = 0; i < n; i++) {
nums[i] = in.nextInt();
}
int num = diffWeight(n, weights, nums);
System.out.println(num);
}
}
/**
*
* @param n 砝码的数量
* @param weights 砝码的重量数组
* @param nums 砝码的数量数组
* @return
*/
private static int diffWeight(int n, int[] weights, int[] nums) {
Set<Integer> set = new HashSet<>();
for (int i = 0; i <= nums[0]; i++) {
set.add(i*weights[0]);
}
for (int i = 1; i < n; i++) {
List<Integer> list = new ArrayList<>(set);
for (int j = 0; j <= nums[i]; j++) {
for (int k = 0; k < list.size(); k++) {
int weight = list.get(k) + j*weights[i];
set.add(weight);
}
}
}
return set.size();
}
}
最长回文字符串
如果一个字符串正读和反渎都一样(大小写敏感) ，则称它为一个[ 回文串Q ]，例如: 1：leVel是一个[回文串] ，因为它的正读和反读都是leVel; 同理a也是[回文串] 2：art不是一个[回文串] ，因为它的反读tra与正读不同 3：Level不是一个[回文串，因为它的反读leveL与正读不同 (因大小写敏感)
给你一个仅包含大小写字母的字符串，请用这些字母构造出一个最长的回文串，若有多个最长的，返回其中字典序最小的回文串。字符串中的每个位置的字母最多备用一次，也可以不用。
样例输入 复制
"abczcccddzz"样例输出 复制
"ccdzazdcc"
import java.util.Arrays;
import java.util.Scanner;
public class Longestpalindromestring {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
char[] chars = scanner.nextLine().toCharArray();
Arrays.sort(chars);
int start=0,end=0;
StringBuilder stringBuilder=new StringBuilder();
char mid='0';
for (int i = 0; i+1 < chars.length;) {
if (chars[i]==chars[i+1]) {
stringBuilder.insert(start++,chars[i]);
stringBuilder.insert(stringBuilder.length()-end++,chars[i+1]);
i+=2;
}else {
if (mid=='0'){
mid=chars[i];
}
i++;
}
}
if (mid!='0'){
stringBuilder.insert(start,mid);
}
System.out.println(stringBuilder.toString());
}
}
设有一个长度为N的数字串，要求选手使用K个乘号将它分成K+1个部分，找出一种分法，使得这K+1个部分的乘积能够为最大。
同时，为了帮助选手能够正确理解题意，主持人还举了如下的一个例子：
有一个数字串：312， 当N=3，K=1时会有以下两种分法：
1) 3*12=36
2) 31*2=62
这时，符合题目要求的结果是：31*2=62
现在，请你帮助你的好朋友XZ设计一个程序，求得正确的答案。
输入
每个测试文件只包含一组测试数据，每组输入有两行：
第一行输入两个自然数N，K（6≤N≤40，1≤K≤6）。
第二行输入一个长度为N的数字串。
输出
对于每组输入数据，输出所求得的最大乘积（一个自然数）。
样例输入 复制
4 2
1231输出
62
import java.util.Scanner;
public class 乘积最大 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int k=scanner.nextInt();
String pre=scanner.next();
int[][] dp=new int[n+1][k+1];
int[][] data=new int[n+1][n+1];
for (int i = 0; i <n ; i++) {
int temp=0;
for (int j = i; j <n ; j++) {
temp=temp*10+Integer.valueOf(pre.charAt(j))-'0';
data[i][j]=temp;
}
}
for(int i=0;i<n;i++)
{
dp[i][0]=data[0][i];
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <=k; j++) {
for (int l = 0; l <i ; l++) {
dp[i][j]=Math.max(dp[i][j],dp[l][j-1]*data[l+1][i]);
}
}
}
System.out.print(dp[n-1][k]);
}
class test{
public void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
int k=scanner.nextInt();
String pre=scanner.next();
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
