- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
AVAudioSession *session = [AVAudioSession sharedInstance];
NSError *error;
if (![session setCategory:AVAudioSessionCategoryPlayAndRecord error:&error]) {
NSLog(@"Category Error: %@", [error localizedDescription]);
}
if (![session setActive:YES error:&error]) {
NSLog(@"Activation Error: %@", [error localizedDescription]);
}
return YES;
}typedef void(^THRecordingStopCompletionHandler)(BOOL);
typedef void(^THRecordingSaveCompletionHandler)(BOOL, id);
@class THMemo;
@interface THRecorderController : NSObject
@property (nonatomic, readonly) NSString *formattedCurrentTime;
// Recorder methods
- (BOOL)record;
- (void)pause;
- (void)stopWithCompletionHandler:(THRecordingStopCompletionHandler)handler;
- (void)saveRecordingWithName:(NSString *)name
completionHandler:(THRecordingSaveCompletionHandler)handler;
// Player methods
- (BOOL)playbackMemo:(THMemo *)memo;
@end@interface THRecorderController () <AVAudioRecorderDelegate>
@property (strong, nonatomic) AVAudioPlayer *player;
@property (strong, nonatomic) AVAudioRecorder *recorder;
@property (strong, nonatomic) THRecordingStopCompletionHandler completionHandler;
@end- (id)init {
self = [super init];
if (self) {
NSString *tmpDir = NSTemporaryDirectory();
NSString *filePath = [tmpDir stringByAppendingPathComponent:@"memo.caf"];
NSURL *fileURL = [NSURL fileURLWithPath:filePath];
NSDictionary *settings = @{
AVFormatIDKey : @(kAudioFormatAppleIMA4),
AVSampleRateKey : @44100.0f,
AVNumberOfChannelsKey : @1,
AVEncoderBitDepthHintKey : @16,
AVEncoderAudioQualityKey : @(AVAudioQualityMedium)
};
NSError *error;
self.recorder = [[AVAudioRecorder alloc] initWithURL:fileURL settings:settings error:&error];
if (self.recorder) {
self.recorder.delegate = self;
[self.recorder prepareToRecord];
} else {
NSLog(@"Error: %@", [error localizedDescription]);
}
}
return self;
}- (BOOL)record {
return [self.recorder record];
}
- (void)pause {
[self.recorder pause];
}
- (void)stopWithCompletionHandler:(THRecordingStopCompletionHandler)handler {
self.completionHandler = handler;
[self.recorder stop];
}
- (void)audioRecorderDidFinishRecording:(AVAudioRecorder *)recorder successfully:(BOOL)success {
if (self.completionHandler) {
self.completionHandler(success);
}
}- (void)saveRecordingWithName:(NSString *)name completionHandler:(THRecordingSaveCompletionHandler)handler {
NSTimeInterval timestamp = [NSDate timeIntervalSinceReferenceDate];
NSString *filename = [NSString stringWithFormat:@"%@-%f.m4a", name, timestamp];
NSString *docsDir = [self documentsDirectory];
NSString *destPath = [docsDir stringByAppendingPathComponent:filename];
NSURL *srcURL = self.recorder.url;
NSURL *destURL = [NSURL fileURLWithPath:destPath];
NSError *error;
BOOL success = [[NSFileManager defaultManager] copyItemAtURL:srcURL toURL:destURL error:&error];
if (success) {
handler(YES, [THMemo memoWithTitle:name url:destURL]);
[self.recorder prepareToRecord];
} else {
handler(NO, error);
}
}
- (NSString *)documentsDirectory {
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
return [paths objectAtIndex:0];
}- (BOOL)playbackMemo:(THMemo *)memo {
[self.player stop];
self.player = [[AVAudioPlayer alloc] initWithContentsOfURL:memo.url error:nil];
if (self.player) {
[self.player play];
return YES;
}
return NO;
}- (NSString *)formattedCurrentTime {
NSUInteger time = (NSUInteger)self.recorder.currentTime;
NSInteger hours = (time / 3600);
NSInteger minutes = (time / 60) % 60;
NSInteger seconds = time % 60;
NSString *format = @"%02i:%02i:%02i";
return [NSString stringWithFormat:format, hours, minutes, seconds];
}- (void)startTimer {
[self.timer invalidate];
self.timer = [NSTimer timerWithTimeInterval:0.5
target:self
selector:@selector(updateTimeDisplay)
userInfo:nil
repeats:YES];
[[NSRunLoop mainRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];
}
- (void)updateTimeDisplay {
self.timeLabel.text = self.controller.formattedCurrentTime;
}https://www.jianshu.com/p/e7788471e57a
平衡字符串
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.util.function.Function;
class Main {
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
String input_str = in.nextLine();
//预设值
Map<Character,Integer> char_count = new HashMap<Character,Integer>();
//遍历字符串
for(int i=0; i<input_str.length(); i++) {
char key = input_str.charAt(i);
if(char_count.get(key) == null) {
char_count.put(key, 1);
} else{
char_count.put(key,char_count.get(key)+1);
}
}
//遍历WASD,防止输入没有这三个字符
for(int i=0; i<"WASD".length(); i++) {
char key = "WASD".charAt(i);
if(char_count.get(key) == null) {
char_count.put(key, 0);
}
}
// 特殊情况
if (char_count.get('W') == char_count.get('A') &&
char_count.get('W') == char_count.get('S') &&
char_count.get('W') == char_count.get('D')) {
System.out.println(0);
return;
}
// 左右区间位置
int left = 0;
int right = 0;
int length = 0;
// 替换的最小长度
int res = input_str.length();
// 出现次数最多的字母
int max_char_num = 0;
// 可替换字母个数, 随着指针移动，如果free_char_num 大于0且能被4整除，当前范围满足条件，左指针右移一格，否则右指针右移
int free_char_num = 0;
char_count.put(input_str.charAt(0), char_count.get(input_str.charAt(0)) - 1);
while (true) {
max_char_num = Math.max(Math.max((Math.max(char_count.get('W'), char_count.get('S'))), char_count.get('A')), char_count.get('D'));
length = right - left + 1;
free_char_num = length - ((max_char_num - char_count.get('W')) + (max_char_num - char_count.get('S')) + (max_char_num - char_count.get('A')) + (max_char_num - char_count.get('D')));
if (free_char_num >= 0 && free_char_num % 4 == 0){
if(length<res) {
res = length;
}
char_count.put(input_str.charAt(left), char_count.get(input_str.charAt(left)) + 1);
left++;
} else {
right++;
char_count.put(input_str.charAt(right), char_count.get(input_str.charAt(right)) - 1);
}
if (right >= input_str.length()-1)// 越界即结束
break;
}
System.out.println(res);
}
}方法一：滑动窗口
思路与算法
设 partial=n4partial=4n，我们选择 ss 的一个子串作为「待替换子串」，只有当 ss 剩余的部分中 ‘Q’‘Q’，‘W’‘W’，‘E’‘E’，‘R’‘R’ 的出现次数都小于等于 partialpartial 时，我们才有可能使 ss 变为「平衡字符串」。
如果原始的 ss 就是 「平衡字符串」，我们直接返回 00，否则我们按照以下思路求解。
从小到大枚举「待替换子串」的左端点 ll，为了使得替换的长度最小，我们要找到最近的右端点 rr，使得去除 [l,r)[l,r) 之后的剩余部分满足上述条件。不难发现，随着 ll 的递增，rr 也是递增的。
具体的，我们使用滑动窗口来维护区间 [l,r)[l,r) 之外的剩余部分中 ‘Q’‘Q’，‘W’‘W’，‘E’‘E’，‘R’‘R’ 的出现次数，当其中一种字符的出现次数大于 partialpartial 时，令 s[r]s[r] 的出现次数减 11，并使得 rr 向右移动一个单位。该操作一直被执行，直到条件被满足或者 rr 到达 ss的末尾。
如果找到了使得条件被满足的 rr，我们用 r−lr−l 来更新答案，然后令 s[l]s[l] 的出现次数加 11，并使得 ll向右移动一个单位进行下一次枚举。否则，后序的 ll 也将不会有合法的 rr，此时我们可以直接跳出循环。对于所有合法的 [l,r)[l,r)，取 r−lr−l 的最小值做为答案。
class Solution {
public int balancedString(String s) {
int[] cnt = new int[26];
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
cnt[idx(c)]++;
}
int partial = s.length() / 4;
int res = s.length();
if (check(cnt, partial)) {
return 0;
}
for (int l = 0, r = 0; l < s.length(); l++) {
while (r < s.length() && !check(cnt, partial)) {
cnt[idx(s.charAt(r))]--;
r++;
}
if (!check(cnt, partial)) {
break;
}
res = Math.min(res, r - l);
cnt[idx(s.charAt(l))]++;
}
return res;
}
public int idx(char c) {
return c - 'A';
}
public boolean check(int[] cnt, int partial) {
if (cnt[idx('Q')] > partial || cnt[idx('W')] > partial || cnt[idx('E')] > partial || cnt[idx('R')] > partial) {
return false;
}
return true;
}
}
- 题目保证 字符数是4的倍数：则只要在「待替换子串」外的部分 字符的频次 小于等于 n / 4，都可以通过对「待替换子串」进行替换操作，使得字符串变为「平衡字符串」
- 分析至此：我们可以利用滑动窗口去选中可能的「待替换子串」
- 只要在「待替换子串」外的部分 字符的频次 小于等于 n / 4，窗口内的「待替换子串」都合法，可以进行收缩窗口，在满足合法时，进行最小长度统计
- 具体的实现「对窗口外字符词频的统计工作」：
- 可以先对总体字符词频进行统计
- 然后再字符被纳入窗口时进行词频缩减，即可完成「对窗口外字符词频的统计工作」
class Solution { public int balancedString(String s) { char[] cs = s.toCharArray(); int n =cs.length; int m = n / 4; int[] cnt = new int[256]; for (int k = 0; k < n; k ++) cnt[s.charAt(k)] ++; if (cnt['Q'] == m && cnt['W'] == m && cnt['E'] == m && cnt['R'] == m) return 0; int ans = n; for (int i = 0, j = 0; j < n; j ++) { cnt[s.charAt(j)] --; while (cnt['Q'] <= m && cnt['W'] <= m && cnt['E'] <= m && cnt['R'] <= m) { ans = Math.min(j - i + 1, ans); cnt[s.charAt(i ++)] ++; } } return ans; } }
农场施肥
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.math.BigInteger;
import java.util.stream.Stream;
class Main {
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
int m = in.nextInt();
int n = in.nextInt();
in.nextLine();
Integer[] fields = Arrays.stream(in.nextLine().split(" ")).map(Integer::parseInt).toArray(Integer[]::new);
// 最少天数小于果林大小可直接返回-1
if (n<m) {
System.out.println(-1);
return;
}
// 最少天数等于果林大小可直接返回max(fields)
if (n==m) {
System.out.println((int) Collections.max(Arrays.asList(fields)));
return;
}
//排序找到最大最小值
Arrays.sort(fields);
int left = 0;
int right = fields[fields.length - 1];
int result = -1;
while (left +1 < right) {
//取中间位置的值作为效能k，这里的k取得是其在数组中的index
int k = (int) Math.ceil((double)(left + right) / 2);
int res = cal(k, fields);
if (res - n > 0) {
left = k;
} else {
result = k;
right = k;
}
}
System.out.println(result);
}
//判断效能为k时，所需总天数
public static int cal(int k, Integer[] fields) {
int days = 0;
for (int i=0;i<fields.length;i++) {
days += Math.ceil(fields[i] / (double)k);
}
return days;
}
}组装新的数组
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.math.BigInteger;
import java.util.stream.Stream;
class Main {
public static int m;
public static int min_num;
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
Integer[] nums = Arrays.stream(in.nextLine().split(" ")).map(Integer::parseInt).toArray(Integer[]::new);
m = in.nextInt();
//排序找到最小值
Arrays.sort(nums);
min_num = nums[0];
System.out.println(dfs(nums, 0, 0, 0));
}
public static int dfs(Integer[] nums, int index, int sum, int count) {
if (sum > m) {
return count;
}
//满足边界条件+1
if (sum <= m && m - min_num < sum) {
return count + 1;
}
for (int i = index; i < nums.length; i++) {
count = dfs(nums, i, sum + nums[i], count);
}
return count;
}
}荒地建设电站（二维前缀和）
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
//处理输入
Scanner in=new Scanner(System.in);
List<Integer> params =Arrays.stream(in.nextLine().split(" "))
.map(Integer::parseInt)
.collect(Collectors.toList());
int n = params.get(0);
int m = params.get(1);
int c = params.get(2);
int k = params.get(3);
int[][] matrix = new int [n][m];
for (int i=0;i<n;i++) {
String[] num_strs =in.nextLine().split(" ");
for (int j=0;j<m;j++) {
matrix[i][j] = Integer.parseInt(num_strs[j]);
}
}
System.out.println(get_area_count(matrix, k, c));
}
public static int get_area_count(int[][] mat, int threshold, int c) {
int n = mat.length;
int m = mat[0].length;
int[][] s = new int [n+1][m+1];
//1、生成前缀和子矩阵
for (int i = 1; i <= n; ++i){
for (int j = 1; j <= m; ++j) {
//s[i][j]表示以[i,j]作为矩阵最右下角的最大矩阵的前缀和
//解释：以点[i,j]作为作为最右下角的最大矩阵的前缀和需要加上点[i-1,j]和点[i,j-1]的前缀和，然而会重复多加一个点[i-1][j-1]的前缀和，所以要减一个
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + mat[i - 1][j - 1];
}
}
int ans = 0;
//2、遍历前缀和矩阵，获得边长等于c的矩阵
for (int i = c; i <= n; ++i) {
for (int j = c; j <= m; ++j) {
//重点理解：减去点[i-c][j]和点[i][j-c]的矩阵前缀和，剩下来的为一个边长为c正方形，注意点[i-c][j-c]减了两次，需要加一个回来
if (s[i][j] - s[i - c][j] - s[i][j - c] + s[i - c][j - c] >= threshold)
ans += 1;
}
}
return ans;
}
}简单的解压缩算法
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
class Main {
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
//防止最后一个字符是数字
String input_str = in.nextLine() + " ";
LinkedList<String> stack = new LinkedList<>();
// bracket_pos 保存的是所有花括号出现的位置
LinkedList<Integer> bracket_pos = new LinkedList<>();
// 保存数字的字符串
String number_str = "";
for (int i = 0; i < input_str.length(); i++) {
char c = input_str.charAt(i);
//数字
if (c >= '0' && c <= '9') {
number_str += c;
continue;
}
if (number_str.length() > 0) {
int repeat_count = Integer.parseInt(number_str);
number_str = "";
// 若此时栈顶是 } 字符, 将对应的字母重复repeat_count次
if ("}".equals(stack.getLast())) {
//获取上一个 { 的位置
int pos = bracket_pos.removeLast();
//删除左右{}
stack.remove(pos);
stack.removeLast();
// 重复{}之间的字母
repeat_operation(stack, pos, repeat_count);
} else {
//不是 } 字符, 简单重复栈顶字符对应次即可
repeat_operation(stack, stack.size() - 1, repeat_count);
}
}
// { 字符
if (c == '{') {
bracket_pos.add(stack.size());
}
// 其他字符 (字母 + })
stack.add(c + "");
}
// 输出
System.out.println(stack.stream().collect(Collectors.joining()));
}
// 重复{}内的字母, 并重新入栈
public static void repeat_operation(LinkedList<String> stack, int pos, int repeat_count) {
int count = stack.size() - pos;
// temp_stack用于存储弹栈数据
String[] temp_stack = new String[count];
while (count >= 1) {
count -= 1;
temp_stack[count] = stack.removeLast();
}
String temp_str = String.join("", temp_stack);
StringBuilder result = new StringBuilder();
//重复repeat_count次
for (int i = 0; i < repeat_count; i++) {
result.append(temp_str);
}
stack.add(result.toString());
}
}垃圾短信识别
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
class Main {
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[][] id_pairs = new int[n][2];
for (int i = 0; i < n; i++) {
id_pairs[i][0] = in.nextInt();
id_pairs[i][1] = in.nextInt();
}
int id = in.nextInt();
//发送短信和收到短信的统计信息
LinkedList<Integer> send_list = new LinkedList<>();
LinkedList<Integer> receive_list = new LinkedList<>();
// key为指定ID, value为其send的个数
HashMap<Integer, Integer> send_map = new HashMap<>();
// key为指定ID, value为其receive 的个数
HashMap<Integer, Integer> receive_map = new HashMap<>();
for (int[] id_pair : id_pairs) {
int sender = id_pair[0];
int receiver = id_pair[1];
if (sender == id) {
send_list.addLast(receiver);
send_map.put(receiver, send_map.getOrDefault(receiver, 0) + 1);
}
if (receiver == id) {
receive_list.addLast(sender);
receive_map.put(sender, receive_map.getOrDefault(sender, 0) + 1);
}
}
// 去重结果
HashSet<Integer> send_set = new HashSet<>(send_list);
HashSet<Integer> receive_set = new HashSet<>(receive_list);
// 交集
List<Integer> intersect = send_list.stream().filter(receive_set::contains).collect(Collectors.toList());
// 两个指标 L & M
int L = send_set.size() - intersect.size();
int M = send_list.size() - receive_list.size();
boolean flag = false;
if (L > 10 || M > 5) {
flag = true;
}
if (!flag) {
// 指标 N
for (Integer single_id : intersect) {
if (send_map.containsKey(single_id)
&& receive_map.containsKey(single_id)
&& send_map.get(single_id) - receive_map.get(single_id) > 5) {
flag = true;
break;
}
}
}
System.out.println(flag + " " + L + " " + M);
}
}缓存需要最少金币数 /静态扫描
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.math.BigInteger;
import java.util.stream.Stream;
class Main {
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
int m = Integer.parseInt(in.nextLine());
List<Integer> file_ids =Arrays.stream(in.nextLine().split(" "))
.map(Integer::parseInt)
.collect(Collectors.toList());
List<Integer> sizes =Arrays.stream(in.nextLine().split(" "))
.map(Integer::parseInt)
.collect(Collectors.toList());
// key为文件标识 value为文件出现的次数
HashMap<Integer, Integer> file_map = new HashMap<>();
// key为文件标识 value为扫描成本
HashMap<Integer, Integer> file_cost = new HashMap<>();
for (int i = 0; i < file_ids.size(); i++) {
file_map.put(file_ids.get(i), file_map.getOrDefault(file_ids.get(i), 0) + 1);
file_cost.putIfAbsent(file_ids.get(i), sizes.get(i));
}
int result = 0;
for (int k : file_map.keySet()) {
result += Math.min(file_map.get(k) * file_cost.get(k), file_cost.get(k) + m);
}
System.out.println(result);
}
}日志限流
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
//处理输入
Scanner in=new Scanner(System.in);
int N = in.nextInt();
int[] records = new int[N];
long single_total = 0;
for (int i = 0; i < N; i++) {
records[i] = in.nextInt();
single_total += records[i];
}
int total = in.nextInt();
// 一天产生的日志总条数小于等于total
if(single_total <= total) {
System.out.println(-1);
return;
} else {
Arrays.sort(records);
//二分法初始化
int left = total / N;
int right = records[N - 1];
int result = left;
while (right > left+1) {
int mid = (right + left) / 2;
int temp_total = 0;
for (int i=0; i<N; i++){
temp_total += Math.min(records[i], mid);
}
if (temp_total > total) {
right = mid;
} else if (temp_total < total) {
left = mid;
result = mid;
} else {
System.out.println(mid);
return;
}
}
System.out.println(result);
return;
}
}
}最多组合直角三角形个数（全组合）
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.math.BigInteger;
import java.util.stream.Stream;
class Main {
public static ArrayList<Integer> result = new ArrayList<>();
public static ArrayList<Integer[]> paths = new ArrayList<>();
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
// 处理输入
int T = in.nextInt();
for (int i=0;i<T;i++) {
int N = in.nextInt();
int[] nums = new int[N];
for (int j = 0; j < N; j++) {
nums[j] = in.nextInt();
}
Arrays.sort(nums);
dfs(nums, 0, new LinkedList<>());
int[] count = new int[100];
for (int num : nums) {
count[num]++;
}
check(0, count, 0);
Integer max_res = 0;
for (Integer x : result) {
if (x > max_res) {
max_res = x;
}
}
System.out.println(max_res);
result = new ArrayList<>();
}
}
public static void dfs(int[] nums, int index, LinkedList<Integer> sides) {
if (sides.size() == 3) {
if (sides.get(0)*sides.get(0) + sides.get(1)*sides.get(1) == sides.get(2)*sides.get(2)){
paths.add(sides.toArray(new Integer[3]));
return;
}
}
for (int i = index; i < nums.length; i++) {
if (!(i > 0 && nums[i] == nums[i - 1])){
sides.add(nums[i]);
dfs(nums, i + 1, sides);
sides.removeLast();
}
}
}
public static void check(int index, int[] count, int num) {
if (index >= paths.size()) {
result.add(num);
return;
}
for (int i = index; i < paths.size(); i++) {
Integer[] single_path = paths.get(i);
int a = single_path[0];
int b = single_path[1];
int c = single_path[2];
if (count[a] > 0 && count[b] > 0 && count[c] > 0) {
count[a]--;
count[b]--;
count[c]--;
num++;
check(i + 1, count, num);
num--;
count[a]++;
count[b]++;
count[c]++;
}
}
result.add(num);
}
}工单调度策略
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
//处理输入
Scanner in=new Scanner(System.in);
int n = in.nextInt();
int[][] tasks = new int[n][2];
for(int i = 0;i<n;i++){
tasks[i][0] = in.nextInt();
tasks[i][1] = in.nextInt();
}
// 按照积分大小先排序
Arrays.sort(tasks, (a,b) -> b[1] - a[1]);
/*for(int i = 0;i<n;i++){
System.out.println(tasks[i][0]);
System.out.println(tasks[i][1]);
}*/
// 每个SLA任务可获得的积分
int[] maxScore = new int[n+1];
for (int i = 0; i < tasks.length; i++) {
//如果当前这个SLA任务为0, 那么优先处理最大积分
if (maxScore[tasks[i][0]] == 0) {
maxScore[tasks[i][0]] = tasks[i][1];
} else {
// SLA 减去 工单处理耗时1小时 得到下一个SLA
int t = tasks[i][0] - 1;
//查看下一个SLA有没有被赋值过
while (t > 0 && maxScore[t] != 0) {
t--;
}
//若找到下一个SLA没有被赋值过的，可以直接处理当前工单
if (t > 0) {
maxScore[t] = tasks[i][1];
}
}
}
int res = 0;
for (int score:maxScore) {
res += score;
}
System.out.println(res);
}
}计算最大乘积
import java.util.Scanner;
import java.util.*;
class Main {
public static int max_product = 0;
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
String str = in.nextLine();
String[] str_list = str.split(",");
//暴力双循环
for(int i=0;i<str_list.length;i++){
for(int j=i+1;j<str_list.length;j++){
get_max_product(str_list[i], str_list[j]);
}
}
System.out.println(max_product);
}
}
public static void get_max_product(String a,String b){
int product = a.length() * b.length();
if(product <= max_product){
return;
}else{
for(int i=0;i<a.length();i++){
for(int j=0;j<b.length();j++){
if(a.charAt(i)==b.charAt(j)){
return;
}
}
}
max_product = product;
}
}
}区间交集
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
class Main {
public static int min_times;
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
List<Integer> nums =Arrays.stream(in.nextLine().split(" "))
.map(Integer::parseInt)
.collect(Collectors.toList());
// 先计算交集
List<int[]> res = new ArrayList<>();
for (int i = 0; i < nums.size(); i += 2) {
for (int j = i + 2; j < nums.size(); j += 2) {
int left = Math.max(nums.get(i), nums.get(j));
int right = Math.min(nums.get(i + 1), nums.get(j + 1));
if (left <= right) {
res.add(new int[]{left, right});
}
}
}
// 自定义排序
int[][] res_array = res.toArray(new int[res.size()][]);
Arrays.sort(res_array, (a, b) -> (a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]));
// 求交集的并集
int[][] result = new int[res_array.length][2];
int index = -1;
for (int[] single_array : res_array) {
if (index == -1 || single_array[0] > result[index][1]) {
result[++index] = single_array;
} else {
result[index][1] = Math.max(result[index][1], single_array[1]);
}
}
int[][] last = Arrays.copyOf(result, index + 1);
for (int i = 0; i < last.length; i++) {
System.out.print(last[i][0]);
System.out.print(" ");
System.out.print(last[i][1]);
if (i != last.length - 1) {
System.out.print(" ");
}
}
}
}基站维护最短距离
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.math.BigInteger;
class Main {
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
//转为数组
int n = in.nextInt();
int[][] matrix = new int[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
matrix[i][j] = in.nextInt();
}
}
System.out.println(solve(n, matrix));
}
public static int solve(int n, int[][] matrix) {
int MAX=1<<n;
int[][] dp = new int[n][1<<n];
for(int i=0;i<n;i++) {
for(int j=0;j<(1<<n);j++) {
dp[i][j]=n*500;
}
}
for(int i=0;i<n;i++) {
dp[i][1<<i]=matrix[0][i];
}
//j为当前状态
for(int j=0;j<MAX;j++) {
//i为当前基站
for(int i=0;i<n;i++) {
if((j&(1<<i))==0) {
continue;
} //注意运算符优先级
//k为下一个基站
for(int k=0;k<n;k++) {
dp[i][j]=Math.min(dp[i][j], dp[k][j&(~(1<<i))]+matrix[k][i]);
}
}
}
return dp[0][MAX-1];
}
}包含101的数（数位DP）
数位DP学习整理（数位DP看完这篇你就会了）_unique_pursuit的博客-CSDN博客_数位dp
import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.math.BigInteger;
import java.util.stream.Stream;
import java.time.ZoneId;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
class Main {
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
int left = in.nextInt();
int right = in.nextInt();
System.out.println(dp(right)-dp(left-1));
}
public static int dp(int num) {
// 10 -> [1,0,1,0,0]
String number_str=Integer.toBinaryString(num);
Integer[] single_binary_nums = new Integer[number_str.length()];
for (int i=0;i<number_str.length();i++) {
single_binary_nums[i] = Integer.parseInt(number_str.charAt(i)+"");
}
int[][][] binary_dp = new int[single_binary_nums.length][2][2];
return search(0, true, binary_dp, single_binary_nums, 0, 0);
}
public static int search(int p, boolean flag, int[][][] binary_dp, Integer[] single_binary_nums, int pre, int prepre) {
if (p == single_binary_nums.length) {
return 1;
}
if (!flag && binary_dp[p][pre][prepre] != 0) {
return binary_dp[p][pre][prepre];
}
int index = flag ? single_binary_nums[p] : 1;
int count = 0;
for (int i = 0; i < index+1; i++) {
if (i == 1 && pre == 0 && prepre == 1) {
continue;
}
count += search(p + 1, flag && i == index, binary_dp, single_binary_nums, i, pre);
}
if (!flag) {
binary_dp[p][pre][prepre] = count;
}
return count;
}
}import java.util.Scanner;
import java.util.*;
import java.util.stream.Collectors;
import java.math.BigInteger;
class Main {
public static void main(String[] args) {
// 处理输入
Scanner in = new Scanner(System.in);
int N = in.nextInt();
double result = 0;
in.nextLine();
for(int i=0;i<N;i++){
// 字符串换算大小
result += exchange(in.nextLine());
}
System.out.println((int)result);
}
public static double exchange(String str){
String temp = "";
double money = 0;
for(int i=0; i<str.length(); i++){
char c = str.charAt(i);
if(Character.isDigit(c)){
temp += c;
}else {
if(temp == ""){
continue;
}
money += transform( temp, c);
i += 2; // 因为货币的简写至少为3位，所以可以跳两位
temp = "";
}
}
return money;
}
public static double transform(String numStr, char str){
double money = 0;
int num = Integer.valueOf(numStr);
if(str == 'C'){
money = num * 100;
}else if(str == 'J'){
money = (double) num * 10000 / 1825;
}else if(str == 'H'){
money = (double) num * 10000 / 123;
}else if(str == 'E'){
money = (double) num * 10000 / 14;
}else if(str == 'G'){
money = (double) num * 10000 / 12;
}else if(str == 'f'){
money = num * 1;
}else if(str == 's'){
money = (double) num * 100 / 1825;
}else if(str == 'c'){
money = (double) num * 100 / 123;
}else if(str == 'e'){
money = (double) num * 100 / 14;
}else if(str == 'p'){
money = (double) num * 100 / 12;
}
return money;
}
}
数组组装
题目描述
给你一个整数M和数组N，N中的元素为连续整数，要求根据N中的元素组装成新的数组R，组装规则:
1.R中元素总和加起来等于M
2.R中的元素可以从N中重复选取
3.R中的元素最多只能有1个不在N中，且比N中的数字都要小(不能为负数)
输入描述
第一行输入是连续数组N，采用空格分隔第二行输入数字M
输出描述
输出的是组装办法数量，int类型
1：第三个规则就是迷惑项，说的有点绕，另外一个元素可以随便补的意思就是，从N中任意选取元素，使得元素之和sum满足下面的条件：
M - min(N) < sum ≤ M
2：这样转换完了之后，其实就转变成了一个leetcode上的原题：组合总数。
3：简单的回溯算法，选择数字，直到满足条件停止回溯。
给一块n*m的地块，相当于n*m的二维数组，每个元素的值表示这个小地块的发电量；求在这块地上建立正方形的边长为c的发电站，发电量满足目标电量k的地块数量。
输入描述：
第一行为四个按空格分隔的正整数，分别表示n, m , c k
后面n行整数，表示每个地块的发电量
输出描述：
输出满足条件的地块数量
示例：
输入：
2 5 2 6 // n m c k，下面每行是n*m地块每格的发电量
1 3 4 5 8
2 3 6 7 1
输出：
4
说明：
满足条件的地块有以下几种
第一种：
1 3
2 3
第二种：
3 4
3 6
第三种：
4 5
6 7
第四种：
5 8
7 1
iphone - layer.renderInContext doesn't take layer.mask into account? - Stack Overflow
objective c - ios: Screenshot doesn't display mask Layer - Stack Overflow
iphone - How to take a layer's snapshot with mask layer? - Stack Overflow
1047
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
