1、整数逆序
要求设计一个程序，输入一个整数，并逆序输出。
input:123 output:321
input:120 output:21
学过了微机原理就很容易想到这个思路：用%10来获得最末位的数字，用/10来删去最末位的数字。
获取了就要想办法保存，例如输入123
| 获取数字 | 实际保存值 |
|---|---|
| 3 | 3 * 10 * 10=300 |
| 2 | 2 * 10 = 20 |
| 1 | 1 |
下面是程序代码：
System.out.println("输入需要逆序的整数:");
Scanner input = new Scanner(System.in);
int num = input.nextInt();
int result = 0;
while (num != 0) {
int a = num % 10;
result = result * 10 + a;
num /= 10;
}
System.out.println(result);
那么如果要求要把逆序后处于最高位的0也输出呢？这反而更简单了。
System.out.println("输入需要逆序的整数:");
Scanner input = new Scanner(System.in);
int num = input.nextInt();
while (num != 0){
System.out.print(num%10);
num /= 10;
}
但这种写法不太好，如果题目只要求返回逆序后的字符串，不要求输出呢。所以应该养成保存结果的习惯，最后是否输出就看题目要求。
System.out.println("输入需要逆序的整数:");
Scanner input = new Scanner(System.in);
int num = input.nextInt();
String str = "";
while (num != 0){
str += num%10;
num /= 10;
}
System.out.println(str);
拓展思考1：
逆序输出问题，如果对数据机构熟悉的话就不难想到数组这一工具，试一试吧。
System.out.println("输入需要逆序的整数:");
Scanner input = new Scanner(System.in);
int num = input.nextInt();
String str1 = Integer.toString(num);//推荐用这个
// String str2 = String.valueOf(num);
// String str3 = "" + num;
char[] chars = str1.toCharArray();
for( int i = chars.length-1;i>=0;i--){
System.out.print(chars[i]);
}
再补充一些小知识，
- 上面列了三种把Int转String的方法，通常用toString，因为valueOf方法内部也是调用了toString，而拼接空字符串的形式会多创建1个对象，浪费内存。不能用（String）强转，会报错的。
- 那么String转Int怎么转呢，我通常用的是parseInt。
Int num = Integer.parseInt(str); - 可以直接打印char[]
因为输出流System.out是PrintStream对象，PrintStream有多个重载的println方法，其中一个就是public void println(char[] x)，直接打印字符数组的话，不像int[]等其他数组，它会直接调用这个方法来打印，因而可以打印出数组内容，而不是地址。
找到原题了，7. 整数反转
难点在于溢出问题。
public int reverse(int x) {
// int res = 0;
// while (x != 0) {
// res = res * 10 + x % 10;
// x /= 10;
// }
// return res;
int ret = 0;
while(x != 0) {
int temp = ret*10 + x%10;
if(temp / 10 != ret)
return 0;
ret = temp;
x /= 10;
}
return ret;
}
2、二维平面整数点集最大值的集合
P为给定的二维平面整数点集。定义 P 中某点x，如果x满足 P 中任意点都不在 x
的右上方区域内（横纵坐标都大于x），则称其为“最大的”。求出所有“最大的”点的集合。（所有点的横坐标和纵坐标都不重复, 坐标轴范围在[0,
1e9) 内）如下图：实心点为满足条件的点的集合。请实现代码找到集合 P 中的所有 ”最大“ 点的集合并输出。
输入描述：
第一行输入点集的个数 N， 接下来 N 行，每行两个数字代表点的 X 轴和 Y 轴。
对于 50%的数据, 1 <= N <= 10000;
对于 100%的数据, 1 <= N <= 500000;
输出描述：
输出“最大的” 点集合， 按照 X 轴从小到大的方式输出，
每行两个数字分别代表点的 X 轴和 Y轴。
思路：
- 根据最近学过的数据结构思想，处理这种新的集合类型，一般先建的类，把集合的属性存起来，这个集合是最大点集合，属性就是X和Y
- 找共性，发现最大点集合都有个特点就是最大点的右上方是空的，即不存在属性x和y同时比它还大的点
- xy都最大的固然是最大点，但有些x不是最大、y也不是最大的也能是最大点，好像还是很难下手
- 灵活一点，从极端值开始处理看看能不能找到规律，我们找到最大的y值所在的点，这个一定是最大点，把这个点定义成maxPoint。那么，从这个点往下看，用下个点的x值跟它的x值比较，如果比它大就是最大点了。那么可以这个点定义成新的maxPoint。这样就可以解决问题了!
前几天学排序，我这个设定maxPoint的方式就是选择排序的minIndex启发的。
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class MaxPoint {
class Point {
int x;
int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
Point[] points = new Point[n];
for (int i = 0; i < n; i++){
int x = scanner.nextInt();
int y = scanner.nextInt();
points[i] = new Point(x,y);
}
Arrays.sort(points, new Comparator<Point>() {
@Override
public int compare(Point o1, Point o2) {
return o2.y - o1.y;
}
});
Point maxPoint = points[0];
for (int i = 0; i < points.length; i++){
if (points[i].x >= maxPoint.x){
maxPoint = points[i];
System.out.println(points[i].x + " " + points[i].y);
}
}
}
}
牛客case通过率为80.00%，(怎么有时候提交了还会变成90、70.……)也不清楚哪里出了问题，看一下讨论区大佬的代码吧。
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
ArrayList<Point>list = new ArrayList<>();
int x,y;
for(int i=0;i<n;++i){
x = scan.nextInt();
y = scan.nextInt();
list.add(new Point(x,y));
}
Stack<Point>stack = new Stack<>();
int maxY = Integer.MIN_VALUE;
Collections.sort(list);
for(int i=0;i<list.size();++i){
if(list.get(i).y>=maxY){
stack.push(list.get(i));
maxY = list.get(i).y;
}
}
while(!stack.isEmpty()){
Point p = stack.pop();
System.out.printf("%d %d\n",p.x,p.y);
}
}
static class Point implements Comparable{
public int x,y;
public Point(int x,int y){
this.x = x;
this.y = y;
}
// 按X轴从大到小排，之后只比较Y值即可
@Override
public int compareTo(Object o){
Point p = (Point)o;
return p.x-this.x;
}
}
}
原来用数据结构可以这么轻松地解决问题啊，看来我得先系统学习数据结构了，抛弃对Java基础数组的依赖。
拓展思考
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法
被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现
此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中
的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或
Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或
有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
3、二叉树最底层最右边的结点
原题大概是找到结点8的值，随便画个图吧，从1到8的值分别是A到H。
两周前笔试的我是一脸懵逼的，因为那时候连二叉树是啥都不知道，现在总算是学了点，来尝试一下。
public class BinaryTree<Key extends Comparable<Key>, Value> {
//记录根结点
private Node root;
//记录树中元素的个数
private int N;
private class Node {
//存储键
public Key key;
//存储值
private Value value;
//记录左子结点
public Node left;
//记录右子结点
public Node right;
public Node(Key key, Value value, Node left, Node right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
}
public Value get(Key key) {
return get(root,key);
}
private Value get(Node x, Key key) {
if (x == null){
return null;
}
int cmp = key.compareTo(x.key);
if (cmp > 0) {
return get(x.right,key);
}else if(cmp < 0){
return get(x.left,key);
}else{
return x.value;
}
}
public void put(Key key,Value value) {
root = put(root,key,value);
}
private Node put(Node x, Key key, Value value) {
if (x == null){
N++;
return new Node(key,value,null,null);
}
int cmp = key.compareTo(x.key);
if (cmp > 0){
x.right = put(x.right,key,value);
}else if (cmp < 0){
x.left = put(x.left,key,value);
}else{
x.value = value;
}
return x;
}
public static void main(String[] args) {
BinaryTree<Integer,String> tree = new BinaryTree<>();
//测试插入
tree.put(1,"A");
tree.put(2,"B");
tree.put(3,"C");
tree.put(4,"D");
tree.put(5,"E");
tree.put(6,"F");
tree.put(7,"G");
tree.put(8,"H");
//测试查找
System.out.println(tree.get(1));//A
System.out.println(tree.get(5));//E
System.out.println(tree.get(8));//H
}
}
我这里先通过put方法放入键和元素，接着用get方法获得对应键的元素。
但感觉我记错了，而且我做的也和题意不符，我代码实现的是二叉查找树，所以如果我这样put进去的话，得到的是一条右斜树。
我好像没学过原始的二叉树的实现，去查一下资料吧。
二叉树的顺序存储结构就是使用一维数组存储二叉树中的结点，并且结点的存储位置，就是数组的下标索引。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
深入学习二叉树(一) 二叉树基础
找到了一道和笔试时接近的二叉树的题，这里做一下吧。513. 找树左下角的值
给定一个二叉树，在树的最后一行找到最左边的值。注意: 您可以假设树（即给定的根节点）不为 NULL。
示例 1:
输入:
2
/ \
1 3
输出:
1
示例 2:
输入:
1
/ \
2 3
/ / \
4 5 6
/
7
输出:
7
DFS:找到深度最大的第一个结点
int[] result = new int[]{0,-1};
public int findBottomLeftValue(TreeNode root) {
dfs(root,0);
return result[0];
}
public void dfs(TreeNode root,int depth){
if(root==null) return ;
if(depth>result[1]){
result[0] = root.val;
result[1] = depth;
}
dfs(root.left,depth+1);
dfs(root.right,depth+1);
}
BFS:要按照从右到左的层序遍历，最后一个就是要找的结点
public int findBottomLeftValue(TreeNode root) {
Queue<TreeNode> treeNodes = new LinkedList<>();
treeNodes.offer(root);
while(!treeNodes.isEmpty()){
root = treeNodes.poll();
if(root.right!=null) treeNodes.offer(root.right);
if(root.left!=null) treeNodes.offer(root.left);
}
return root.val;
}
4、游戏（0-1背包问题）
问题描述：给定n种物品和一背包。物品i的重量是w[i]，其价值为v[i]，背包的容量为C。问应如何选择装入背包的物品，使得装入背包中物品的总价值最大?
笔试原题就是把物品改成游戏，把背包改成小明，物品的重量就是花费的精力，价值就是满足感，容量就是小明的精力，其实本质都是一样的。
如果是部分背包问题，用贪心算法解决，0-1背包就用动态规划思想。
1. 当w[i]>j时，v[i][j]=v[i-1][j];//当准备加入新增的物品的容量＞当前背包的容量时，就直接用上一个单元格的装入策略(即最大值）
2. 当j>w[i]时，v[i][j]=max{v[i-1][j],v[i]+v[i-1][j-w[i]]}//当准备加入的新增的物品的容量＜＝当前背包的容量
public static int knapSack(int[] w, int[] v, int C) {
//定义size长度方便后面的操作
int size = w.length;
if (size == 0) {
return 0;
}
//因为dp[][0]无意义，所以这里是C+1而不是C
int[][] dp = new int[size][C + 1];
//只初始化第一行
for (int i = 0; i <= C; i++) {
dp[0][i] = w[0] <= i ? v[0] : 0;
}
//从第二行开始
for (int i = 1; i < size; i++) {
for (int j = 0; j <= C; j++) {
if (w[i] <= j) {
dp[i][j] = Math.max(dp[i - 1][j], v[i] + dp[i - 1][j - w[i]]);
}
}
}
return dp[size - 1][C];//这个就是表格最右下角那个值
}
public static void main(String[] args) {
int[] w = {2, 1, 3, 2};
int[] v = {12, 10, 20, 15};
System.out.println(knapSack(w, v, 10));
}
扫一扫
335
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
