(Die neueste Version 2022) Jianzhi bietet eine Suchalgorithmuslösung an
1. Suche im zweidimensionalen JZ4-Array von „Jianzhi-Angebot“
Titel Beschreibung:
Ideen zur Problemlösung:
Idee:
Betrachten Sie das Array in der oberen rechten Ecke der Matrix: Die Zahl ist der Minimalwert der aktuellen Spalte und der Minimalwert der aktuellen Zeile, also der Mittelwert der Zahl von Zeile zu Spalte, so die Idee der binären Suche verwendet werden.
- Beginnen Sie in der oberen rechten Ecke und überprüfen Sie zuerst die Nummer in der oberen rechten Ecke. Wenn die Nummer mit der Nummer übereinstimmt, die Sie finden möchten, endet der Suchvorgang.
- Wenn die aktuelle Zahl größer als das Ziel ist, entfernen Sie die Spalte, in der sich die Zahl befindet, und das Ziel erscheint nur in der Zeile, da die Zahlen in dieser Spalte größer als das Ziel sind.
- Wenn die aktuelle Zahl kleiner als das Ziel ist, wird die Zeile, in der sich die Zahl befindet, eliminiert und die Spalte wird durchsucht, da die Zahlen in dieser Reihe alle kleiner als das Ziel sind.
Programmatische Umsetzung (Java):
public class Solution {
public boolean Find(int target, int [][] array) {
int rows = array.length;
int cols = array[0].length;
int row = rows - 1;
int col = 0;
while (col < cols && row >= 0) {
if (target > array[row][col]) {
col++;
} else if (target < array[row][col]) {
row--;
} else {
return true;
}
}
return false;
}
}
2. Die Mindestanzahl von JZ11-Rotationsarrays im "Jianzhi-Angebot"
Titel Beschreibung:
Problemlösungsidee:
Array stellt ein inkrementell sortiertes rotierendes Array dar, wobei linke und rechte Zeiger verwendet werden, um die linke Grenze bzw. rechte Grenze des Arrays darzustellen, und die tiefgestellte Mitte des mittleren Elements des Arrays = (links + rechts)/2 .
Ein Standard-Array mit aufsteigender Sortierung hat immer array[left] >= array[right], wenn array[left] < array[mid], bedeutet dies, dass sich das kleinste Element auf der rechten Seite von mid befindet, also left = mid; array[ left ] > array[mid], das kleinste Element befindet sich auf der linken Seite von mid, also right = mid. Bis left und right benachbart sind, ist array[right] das kleinste Element. . Aber es gibt zwei Spezialfälle:
Die erste, d. h. die Array-Rotation ist dasselbe wie keine Rotation, d. h. Array[links] < Array[rechts], und Array[links] ist zu diesem Zeitpunkt das kleinste Element.
Beim zweiten Typ, Array[links] == Array[rechts] == Array[mid], kann sich das kleinste Element zu diesem Zeitpunkt auf der linken Seite von mid oder auf der rechten Seite befinden. Daher können zu diesem Zeitpunkt nur die Daten zwischen links und rechts durchlaufen werden, um das kleinste Element zu finden.
Programmierumsetzung:
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
int l = 0;
int r = array.length - 1;
//退出条件：l=r,这时候数组里只剩下一个元素
while (l < r) {
//如果此时数组是严格递增的，直接返回最左边元素
if (array[l] < array[r]) {
return array[l];
}
int mid = (l + r) / 2;
//array[mid] > array[l]，说明mid在左边，更新l
if (array[mid] > array[l]) {
l = mid + 1;
//array[mid] < array[l]，说明mid在右边，更新r
} else if (array[mid] < array[l]) {
r = mid;
//mid=l，说明左边有连续多个相同的值，l后移一位
} else {
l++;
}
}
return array[l];
}
}
3. Anordnung der JZ38-Saiten im „Jianzhi-Angebot“
Titel Beschreibung:
Programmatische Umsetzung (Java):
import java.util.*;
public class Solution {
ArrayList<String> res = new ArrayList<>();
ArrayList<Character> list = new ArrayList<>();
boolean[] visited;
public ArrayList<String> Permutation(String str) {
if (str.length() == 0) {
res.add("");
return res;
}
visited = new boolean[str.length()];
char[] chars = str.toCharArray();
Arrays.sort(chars);
dfs(chars, 0);
return res;
}
void dfs(char[] arr, int k){
//搜索到底，把一条路径加入到res集合中
if(arr.length == k){
res.add(charToString(list));
return;
}
//剪枝。
for(int i = 0; i < arr.length; i++){
//从第二个字符开始，如果连续两个字符一样并且上一个没被访问过，说明arr[i]和arr[i - 1]在同一层，剪枝
if(i > 0 && arr[i] == arr[i - 1] && visited[i - 1] == false){
continue;
}
if(visited[i] == false){
visited[i] = true;
list.add(arr[i]);
dfs(arr, k + 1);
//回溯
list.remove(list.size() - 1);
visited[i] = false;
}
}
}
//把字符型集合转化为字符串
String charToString(ArrayList<Character> list){
StringBuilder str = new StringBuilder();
for(int i = 0; i < list.size(); i++){
str.append(list.get(i));
}
return str.toString();
}
}
4. Eine bestimmte Nummer in der JZ44-Nummernfolge von „Jianzhi-Angebot“
Titel Beschreibung:
Ideen zur Problemlösung:
Zum Beispiel, um die 1001. Ziffer zu finden,
1) Es gibt 10 Werte von 1 Ziffer: 0~9, die Zahl ist 10×1=10, offensichtlich 1001>10, überspringe diese 10 Werte, Schau für die 991. (1001-10) Ziffern hinten.
2) Es gibt 90 zweistellige Zahlen: 10~99, die Zahl ist 90×2=180 und 991>180, finden Sie weiterhin die 811. (991-180) Zahl auf der Rückseite.
3) Es gibt 900 3-stellige Werte: 100~999, die Zahl ist 900×3=2700 und 811<2700, was anzeigt, dass die 811. Stelle in dem Wert mit 3 Stellen ist. Da 811 = 270 × 3 + 1 ist, ist die 811. Stelle der 270. Wert, beginnend mit 100, was die zweite Zahl von 370 ist, was 7 ist.
Gemäß dieser Regel können andere Nummern erhalten werden.
Programmierimplementierung (Java):
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param n int整型
* @return int整型
*/
public int findNthDigit (int n) {
// write code here
//bit记录某个数字是多少位的：123是3位，12是2位
int bit = 1;
//初始值：1~9为1,10~99为10,100~999为100
long start = 1;
//某个范围有多少个数字，1~9有9个,10~99有90个,100~999有900个
long count = 9;
if (n == 0) {
return 0;
}
//找出是多少位的（范围）
while (n > count) {
n -= count;
bit++;
start *= 10;
count = bit * start * 9;
}
//找出具体是那个数字
String num = (start + (n - 1) / bit) + "";
//获取那个数字的下标
int index = (n - 1) % bit;
return Integer.parseInt(num.charAt(index) + "");
}
}