北大POJ 1000 ~ 1009

news2024/11/19 9:22:43

1. A+B

🍑 POJ1000 a+b
在这里插入图片描述

🍔 签到题

import java.io.*;
import java.util.*;
public class Main
{
    public static void main(String args[]) throws Exception
    {
            Scanner cin=new Scanner(System.in);
            int a=cin.nextInt(),b=cin.nextInt();
            System.out.println(a+b);
    }
}

2. 高精度

🍑 POJ1001 求高精度幂
在这里插入图片描述
输入

95.123 12
0.4321 20
5.1234 15
6.7592  9
98.999 10
1.0100 12

输出

548815620517731830194541.899025343415715973535967221869852721
.00000005148554641076956121994511276767154838481760200726351203835429763013462401
43992025569.928573701266488041146654993318703707511666295476720493953024
29448126.764121021618164430206909037173276672
90429072743629540498.107596019456651774561044010001
1.126825030131969720661201

🍔 BigDecimal

🍑 BigDecimal.stripTrailingZeros()：移除尾部所有没有意义的 0 
🍑 BigDecimal.toPlainString()：原值转成字符串返回
🍑 BigDecimal.toString()：有可能会返回科学计数法

🍑 String.replaceFirst(String regex, String replacement);
🍁 正则匹配前导零：^0*

import java.math.BigDecimal;
import java.util.*;

public class N1001高精度
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext())
		{
//			double a = sc.nextDouble();
//			BigDecimal bd = new BigDecimal(a);
			BigDecimal bd = sc.nextBigDecimal();
			int b = sc.nextInt();
			String value = bd.pow(b).stripTrailingZeros().toPlainString().replaceFirst("^0*", "");
			System.out.println(value);
		}
	}
}

3. 487-3279

🍑 POJ1002 487-3279
在这里插入图片描述
输入

12
4873279
ITS-EASY
888-4567
3-10-10-10
888-GLOP
TUT-GLOP
967-11-11
310-GINO
F101010
888-1200
-4-8-7-3-2-7-9-
487-3279

输出

310-1010 2
487-3279 4
888-4567 3

🍔 AC代码：字符串存电话号码

🥞 Treeset：自动按升序对元素进行排序
🥞 

import java.util.*;

public class Main
{
	public static void main(String[] args)
	{
		char[] key = new char[128];// 对 字母 映射成 对应的数字
		key['A'] = key['B'] = key['C'] = '2';
		key['D'] = key['E'] = key['F'] = '3';
		key['G'] = key['H'] = key['I'] = '4';
		key['J'] = key['K'] = key['L'] = '5';
		key['M'] = key['N'] = key['O'] = '6';
		key['P'] = key['R'] = key['S'] = '7';
		key['T'] = key['U'] = key['V'] = '8';
		key['W'] = key['X'] = key['Y'] = '9';

//		HashMap<String,Integer> map = new HashMap();  
//不知道为什么使用HashMap超时，TreeMap通过，可能散列函数对样例不太适用吧
		TreeMap<String, Integer> map = new TreeMap();// TreeMap 默认排升序
		String tmp[] = null;
		Scanner sc = new Scanner(System.in);
//		sc = new Scanner(new File("in.txt"));
		int n = sc.nextInt();
		boolean flag = false;
		for (int i = 0; i < n; i++)
		{
			String ss = sc.next();
			char[] arr = ss.toCharArray();// 转为数组处理
			String num = "";
			for (int j = 0; j < arr.length; j++)
			{
				if (arr[j] >= '0' && arr[j] <= '9')
				{
					num += arr[j];// 字符串拼接
				} else if (arr[j] >= 'A' && arr[j] <= 'Z')
				{
					num += key[arr[j]];
				}
			}
			if (map.containsKey(num))
			{
				flag = true;
				map.put(num, map.get(num) + 1);
			} else
			{
				map.put(num, 1);
			}
		}
		if (!flag)
			System.out.println("No duplicates.");
		else
		{
			for (String k : map.keySet())
			{
				int value = map.get(k);
				if (value > 1)
				{
					for (int i = 0; i < k.length(); i++)
					{
						System.out.print(k.charAt(i));
						if (i == 2)
							System.out.print("-");
					}
					System.out.println(" " + value);
				}
			}
		}

	}
}

🍑 没考虑高位为 0 的情况
😪 WA版本

import java.util.*;
import java.io.*;

public class Main
{
	static int[] st = new int[256];
	static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

	public static void main(String[] args) throws IOException
	{
//		Scanner sc = new Scanner(System.in);
//		int n = sc.nextInt();//注意 scanf 不处理回车键（会留在缓冲区影响下一次输入）

		int n = Integer.parseInt(in.readLine());
		TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();// key 表示电话号码，value 表示出现次数

		st['A'] = st['B'] = st['C'] = 2;
		st['D'] = st['E'] = st['F'] = 3;
		st['G'] = st['H'] = st['I'] = 4;
		st['J'] = st['K'] = st['L'] = 5;
		st['M'] = st['N'] = st['O'] = 6;
		st['P'] = st['R'] = st['S'] = 7;
		st['U'] = st['V'] = st['T'] = 8;
		st['W'] = st['X'] = st['Y'] = 9;

		for (int i = 0; i < 10; i++)
		{
			st[i + '0'] = i;
		}
		boolean isDuplicate = false;
		for (int i = 0; i < n; i++)
		{
			String s = in.readLine();
			s = s.replace("-", "");
			int len = s.length();
			int num = 0;
//			处理号码
			for (int j = 0; j < len; j++)
			{
				char c = s.charAt(j);
				if (c != '-')
					num = num * 10 + st[c];
			}
//			int t = map.getOrDefault(num, 0);
			int t = map.get(num) == null ? 0 : map.get(num);
			if (t > 0)
				isDuplicate = true;// 只要有一个号码出现一次重复

			map.put(num, t + 1);// 记录号码的次数
		}
		if (!isDuplicate)
		{
			System.out.println("No duplicates.");
		} else
		{
			for (int k : map.keySet())
			{
				int value = map.get(k);
				if (value > 1)
				{
//					out.write(k / 10000 + "-" + k % 10000 + " " + value + "\n");// k%10000 会出现 0 的情况，不可行
					System.out.printf("%03d-%04d %d", k / 10000, k % 10000, value);
				}
			}
		}
		out.flush();
	}
}

4. 叠卡片

🍑 POJ 1003 Hangover
在这里插入图片描述
输入

1.00
3.71
0.04
5.19
0.00

输出

3 card(s)
61 card(s)
1 card(s)
273 card(s)

🍑 大体题意：

🍤 从上到下，第1张卡片能伸出 1/2 的长度，第2张卡片 1/3，第三张 1/4 ……
🍤 问：需要多少张卡片才能伸出 输入 的长度 n
🍤 每张卡片的长度为 1

import java.util.Scanner;

public class Main
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext())
		{
			double n = sc.nextDouble();
			if (n == 0.00)
				break;
			double len = 0;
			int i = 2;
			int ans = 0;
			while (len < n)
			{
				len += 1.0 / i;
				i++;
			}
			System.out.printf("%d card(s)\n", i - 2);
		}
	}
}

5. 财务管理

🍑 POJ1004 Financial Management
在这里插入图片描述
输入

100.00
489.12
12454.12
1234.10
823.05
109.20
5.27
1542.25
839.18
83.99
1295.01
1.75

输出

$1581.42

🍑 输入12个数求平均数

import java.util.Scanner;

public class Main
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		double sum = 0;
		for (int i = 0; i < 12; i++)
			sum += sc.nextDouble();
		
		System.out.printf("$%.2f", sum / 12);//浮点数输出用 %f
	}
}

6. 我想我需要一艘船屋

🍑 POJ 1005 I Think I Need a Houseboat

在这里插入图片描述
输入

2
1.0 1.0
25.0 0.0

输出

Property 1: This property will begin eroding in year 1.
Property 2: This property will begin eroding in year 20.
END OF OUTPUT.

🍑 Π：Math.PI
🍑 求出 坐标 到 原点 的 欧几里得距离 --> 半径 --> 面积 --> 年数（向上取整）

import java.util.Scanner;

public class Main
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for (int i = 1; i <= n; i++)
		{
			double x = sc.nextDouble();
			double y = sc.nextDouble();
			double r = Math.sqrt(x * x + y * y);
			double s = Math.PI * r * r / 2;
			int year = (int) s / 50 + 1;
			System.out.printf("Property %d: This property will begin eroding in year %d.\n", i, year);
		}
		System.out.println("END OF OUTPUT.");
	}
}

7. 生理周期

🍑 POJ 1006 Biohythms

在这里插入图片描述
输入

0 0 0 0
0 0 0 100
5 20 34 325
4 5 6 7
283 102 23 320
203 301 203 40
-1 -1 -1 -1

输出

Case 1: the next triple peak occurs in 21252 days.
Case 2: the next triple peak occurs in 21152 days.
Case 3: the next triple peak occurs in 19575 days.
Case 4: the next triple peak occurs in 16994 days.
Case 5: the next triple peak occurs in 8910 days.
Case 6: the next triple peak occurs in 10789 days.

🍑 跳跃枚举

🍤 缓冲流输入输出
🍤 判断条件放 for 里边
🍤 输出格式注意空格（Presentation Error）

import java.io.*;

public class Main
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
		for (int j = 1;; j++)
		{
			String[] ss = in.readLine().split(" ");
			int p = Integer.parseInt(ss[0]);
			int e = Integer.parseInt(ss[1]);
			int i = Integer.parseInt(ss[2]);
			int d = Integer.parseInt(ss[3]);
			if (p == -1 && e == -1 && i == -1 && d == -1)
				break;
			int k = d + 1;
			for (; (k - p) % 23 != 0; k++)
				;

			for (; (k - e) % 28 != 0; k += 23)
				;

			for (; (k - i) % 33 != 0; k += 23 * 28)
				;

			out.write("Case " + j + ": the next triple peak occurs in " + (k - d) + " days.\n");
		}
		out.flush();
	}
}

🍑 中国剩余定理
🙈 线性同余方程、扩展欧几里得求逆元 （挖个坑）
在这里插入图片描述

import java.io.*;
import java.util.*;

public class Main
{
	public static void main(String[] args) throws IOException
	{
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
		int M = 21252;
		int cnt = 1;
		while (true)
		{
			String[] ss = in.readLine().split(" ");
			int p = Integer.parseInt(ss[0]);
			int e = Integer.parseInt(ss[1]);
			int i = Integer.parseInt(ss[2]);
			int d = Integer.parseInt(ss[3]);

			if (p == -1 && e == -1 && i == -1 && d == -1)
				break;
			int res = (5544 * p + 14421 * e + 1288 * i) % M;
			res -= d;
			if (res <= 0)
				res = (res + M - 1) % M + 1;
			out.write("Case " + cnt + ": the next triple peak occurs in " + res + " days.\n");
		}
		out.flush();
	}
}

8. DNA 排序

🍑 POJ 1007 DNA Sorting
🍑 HDOJ 1379 DNA Sorting
在这里插入图片描述
👨‍🏫 区别：杭电是多组输入

输入

1
	
10 6
AACATGAAGG
TTTTGGCCAA
TTTGGCCAAA
GATCAGATTT
CCCGGGGGGA
ATCGATGCAT

输出

CCCGGGGGGA
AACATGAAGG
GATCAGATTT
ATCGATGCAT
TTTTGGCCAA
TTTGGCCAAA

🍑 按 逆序数 进行 稳定排序

🥞 归并排序求逆序数
🥞 暴力求逆序数也行啦

🍑 HDOJ AC啦

import java.util.Scanner;

public class Main
{
    static int l;
    static char[] a;
    static char[] tmp;
    static boolean[] st;

    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while (T-- > 0)
        {
            l = sc.nextInt();
            int n = sc.nextInt();
            String[] ss = new String[n];
            long[] cnt = new long[n];// 记录每个字符串的逆序数

            for (int i = 0; i < n; i++)
            {
                ss[i] = sc.next();
            }

            for (int i = 0; i < n; i++)
            {
                a = new char[l];
                tmp = new char[l];
                a = ss[i].toCharArray();
                long t = mergeSort(0, l - 1);
                cnt[i] = t;
            }

//            按逆序对升序排序
            int[] mk = new int[n];// 按升序存 DNA 数组下标

            int k = 0;
            st = new boolean[n];
            while (k < n)
            {
                int min = -1;
                for (int i = 0; i < n; i++)
                {
                    if (!st[i] && (min == -1 || cnt[i] < cnt[min]))
                        min = i;
                }
                mk[k++] = min;
                st[min] = true;
            }

            for (int i = 0; i < n; i++)
            {
                System.out.println(ss[mk[i]]);
            }
        }
    }

    // 输入区间的左右边界，返回该区间的逆序数
    private static long mergeSort(int l, int r)
    {
        if (l == r)
            return 0;

        int mid = l + r >> 1;
//        分治求解
        long ans = mergeSort(l, mid) + mergeSort(mid + 1, r);

        int i = l;// 左区间指针
        int j = mid + 1;// 右区间指针
        int k = 0;

        while (i <= mid && j <= r)
        {
            if (a[i] <= a[j])
                tmp[k++] = a[i++];
            else
            {
                tmp[k++] = a[j++];
                ans += mid - i + 1;// 左区间剩余的元素都比当前元素大，更新结果
            }
        }

//        处理掉剩余的元素
        while (i <= mid)
            tmp[k++] = a[i++];
        while (j <= r)
            tmp[k++] = a[j++];

        k = 0;
        for (i = l; i <= r; i++)
            a[i] = tmp[k++];

        return ans;
    }
}

😡 POJ RE啦

import java.util.Scanner;

public class N1007DNA排序
{
	static int l;
	static char[] a;
	static char[] tmp;
	static boolean[] st;

	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		l = sc.nextInt();
		int n = sc.nextInt();
		String[] ss = new String[n];
		long[] cnt = new long[n];// 记录每个字符串的逆序数

		for (int i = 0; i < n; i++)
		{
			ss[i] = sc.next();
		}

		for (int i = 0; i < n; i++)
		{
			a = new char[l];
			tmp = new char[l];
			a = ss[i].toCharArray();
			long t = mergeSort(0, l - 1);
			cnt[i] = t;
		}

//		按逆序对升序排序
		int[] mk = new int[n];// 按升序存 DNA 数组下标

		int k = 0;
		st = new boolean[n];
		while (k < n)
		{
			int min = -1;
			for (int i = 0; i < n; i++)
			{
				if (!st[i] && (min == -1 || cnt[i] < cnt[min]))
					min = i;
			}
			mk[k++] = min;
			st[min] = true;
		}

		for (int i = 0; i < n; i++)
		{
			System.out.println(ss[mk[i]]);
		}
	}

	// 输入区间的左右边界，返回该区间的逆序数
	private static long mergeSort(int l, int r)
	{
		if (l == r)
			return 0;

		int mid = l + r >> 1;
//		分治求解
		long ans = mergeSort(l, mid) + mergeSort(mid + 1, r);

		int i = l;// 左区间指针
		int j = mid + 1;// 右区间指针
		int k = 0;

		while (i <= mid && j <= r)
		{
			if (a[i] <= a[j])
				tmp[k++] = a[i++];
			else
			{
				tmp[k++] = a[j++];
				ans += mid - i + 1;// 左区间剩余的元素都比当前元素大，更新结果
			}
		}

//		处理掉剩余的元素
		while (i <= mid)
			tmp[k++] = a[i++];
		while (j <= r)
			tmp[k++] = a[j++];

		k = 0;
		for (i = l; i <= r; i++)
			a[i] = tmp[k++];

		return ans;
	}
}

9. 玛雅日历

🍑 POJ 1008 Maya Calendar
在这里插入图片描述
输入

3
10. zac 0
11. pop 0
12. zac 1995

输出

3
3 chuen 0
1 imix 0
9 cimi 2801

🍑 思路

🥞 Haab --> 天数 --> Tzolkin
🥞 Tzolkin 的日期格式： a1 b2 c3 d4 e6 f7 g8 ……
🥞 注意边界值取模映射成 0 的问题
🙈 打表存映射值也行，代码可能会简短一些

import java.io.*;
public class Main
{
	static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

	public static void main(String[] args) throws IOException
	{
		int n = Integer.parseInt(in.readLine());
		System.out.println(n);
		while (n-- > 0)
		{
			String[] ss = in.readLine().split(" ");
			String s = ss[0].replace(".", "").trim();
			int d = Integer.parseInt(s);
			int m = getHaab(ss[1]);
			int y = Integer.parseInt(ss[2]);
			int days = d + 1 + (m - 1) * 20 + y * 365;// 日 从0开始，每月 20 天，每年 365 天

//			Tzolkin：每年13个时期，每个时期20种符号，每年 260 天
			int year = days / 260;
			if(days % 260 == 0)//刚好整除说明是前一年最后一天
				year = year - 1;
			days %= 260;//除去整年的时间，剩下的天数
			
			int sym= days % 20;//标记符号 20天一个周期
			String symbol= getName(sym);// getName方法内部特殊处理了 sym = 0 映射到 20 的情况
			
			int num = days % 13;//数字 13 天一个周期
			if(num == 0)// 0 映射成13
				num = 13;
			System.out.println(num + " " + symbol+ " " + year);
		}

	}

//	返回日期对应的代号
	public static String getName(int i)
	{
		if (i == 1)
		{
			return "imix";
		} else if (i == 2)
		{
			return "ik";
		} else if (i == 3)
		{
			return "akbal";
		} else if (i == 4)
		{
			return "kan";
		} else if (i == 5)
		{
			return "chicchan";
		} else if (i == 6)
		{
			return "cimi";
		} else if (i == 7)
		{
			return "manik";
		} else if (i == 8)
		{
			return "lamat";
		} else if (i == 9)
		{
			return "muluk";
		} else if (i == 10)
		{
			return "ok";
		} else if (i == 11)
		{
			return "chuen";
		} else if (i == 12)
		{
			return "eb";
		} else if (i == 13)
		{
			return "ben";
		} else if (i == 14)
		{
			return "ix";
		} else if (i == 15)
		{
			return "mem";
		} else if (i == 16)
		{
			return "cib";
		} else if (i == 17)
		{
			return "caban";
		} else if (i == 18)
		{
			return "eznab";
		} else if (i == 19)
		{
			return "canac";
		} else// 0 即第20个符号
		{
			return "ahau";
		}
	}

//	返回月份名称对应 数值
	private static int getHaab(String str)
	{

		if (str.equals("pop"))
			return 1;
		else if (str.equals("no"))
			return 2;
		else if (str.equals("zip"))
			return 3;
		else if (str.equals("zotz"))
			return 4;
		else if (str.equals("tzec"))
			return 5;
		else if (str.equals("xul"))
			return 6;
		else if (str.equals("yoxkin"))
			return 7;
		else if (str.equals("mol"))
			return 8;
		else if (str.equals("chen"))
			return 9;
		else if (str.equals("yax"))
			return 10;
		else if (str.equals("zac"))
			return 11;
		else if (str.equals("ceh"))
			return 12;
		else if (str.equals("mac"))
			return 13;
		else if (str.equals("kankin"))
			return 14;
		else if (str.equals("muan"))
			return 15;
		else if (str.equals("pax"))
			return 16;
		else if (str.equals("koyab"))
			return 17;
		else if (str.equals("cumhu"))
			return 18;
		else if (str.equals("uayet"))
			return 19;
		return -1;
	}
}

10. 图像边缘检测

🍑 POJ 1009 Edge Detection

在这里插入图片描述
输入

7
15 4
100 15
25 2
175 2
25 5
175 2
25 5
0 0
10
35 500000000
200 500000000
0 0
3
255 1
10 1
255 2
10 1
255 2
10 1
255 1
0 0
0

输出

7
85 5
0 2
85 5
75 10
150 2
75 3
0 2
150 2
0 4
0 0
10
0 499999990
165 20
0 499999990
0 0
3
245 9
0 0
0

🍑 思路

🥞 奇特的输入模式，输入图片宽度
   每行输入 x n，x表示像素值，n 表示顺序数有多少个连续的 x
🥞 像素值有变化，差值才会有区别，关键点在于每一个连续段的起点位置（主要是暴力过不了啊）

🍑 红框/圈 表示原值连续段起点，蓝色位置表示最大差值连续段起点
🍤 假设 蓝色 只分布在 红色 周围 8 个点是正确的，我们暂且只计算每个点的周围8个点
在这里插入图片描述
🍑 照葫芦画瓢（不支持lambda表达式）

import java.util.*;

public class Main
{
	static int N = 1010;
	static Px[] arow = new Px[8 * N];// 存起点周围的点
	static int[][] line = new int[N][2];// 存连续段，con[][0] 存值，con[][1]存长度
	static int wide, idx, total;// wide 存宽度，idx 存连续段数，total 存总像素点数

	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext())
		{
			wide = sc.nextInt();
			if (wide == 0)
				break;

//			初始化
			idx = 0;
			total = 0;
			int val, len;
			while (true)
			{
				val = sc.nextInt();
				len = sc.nextInt();
				if (len <= 0)
					break;
				line[idx][0] = val;
				line[idx++][1] = len;
				total += len;
			}
			System.out.println(wide);
			int pos = 1;// 记录当前位置
			int cnt = 0;
			for (int i = 0; i <= idx; i++)// 枚举每个连续片段
			{
				//减 1 是因为数组下标从 0 开始
				int row = (pos - 1) / wide;// 当前点所在行数
				int col = (pos - 1) % wide;// 当前点所处列数

//				枚举起点周围的 8 个点
				for (int j = row - 1; j <= row + 1; j++)
				{
					for (int k = col - 1; k <= col + 1; k++)
					{
						int t = j * wide + k;// 点
						if (j < 0 || k < 0 || k >= wide || t >= total)// 越界
							continue;
						//周围 8 个点的值全部计算出来存着
						arow[cnt++] = new Px(t + 1, getCode(t + 1));
					}
				}

				pos += line[i][1];// 转到下一个起点
			}
			//按位置升序进行排序
			Arrays.sort(arow, 0, cnt, new Comparator<Px>()
			{
				public int compare(Px o1, Px o2)
				{
					return o1.pos - o2.pos;
				}
			});
			Px tp = arow[0];//tp记录上一个连续段
			for (int i = 0; i < cnt; i++)
			{
				if (arow[i].code == tp.code)//值相等跳过
					continue;
				System.out.println(tp.code + " " + (arow[i].pos - tp.pos));
				tp = arow[i];
			}
			//处理 一下最后一个 连续段
			System.out.println(tp.code + " " + (total - tp.pos+1));
			System.out.println("0 0");
		}
		System.out.println("0\n");
	}

//  输出位置，返回这个位置与周围点的最大差值
	static int getCode(int pos)
	{
		int num = getnum(pos), ret = 0;
		int row = (pos - 1) / wide;// pos所处排数
		int col = (pos - 1) % wide;// pos所处列数
		for (int i = row - 1; i <= row + 1; i++)// 枚举pos周围八个方向
			for (int j = col - 1; j <= col + 1; j++)
			{
				int tpos = i * wide + j;
				if (i < 0 || j >= wide || j < 0 || tpos == pos - 1 || tpos >= total)
					continue;
				int temp = getnum(tpos + 1);
				if (ret < Math.abs(temp - num))
					ret = Math.abs(temp - num);
			}
		return ret;
	}
//	在原图种找出这个位置所在连续段起点的值
	static int getnum(int pos)
	{
		int p = 0, i = 0;
		while (p < pos)
			p += line[i++][1];
		return line[i - 1][0];
	}

//	像素点类
	static class Px
	{
		int pos;// 表示这个像素点的位置
		int code;// 表示这个点的答案值

		public Px(int pos, int code)
		{
			super();
			this.pos = pos;
			this.code = code;
		}
	}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/451266.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

开发常用的 Linux 命令3（文本处理、打包和压缩）

开发常用的 Linux 命令3（文本处理、打包和压缩）

开发常用的 Linux 命令3&#xff08;文本处理、打包和压缩&#xff09; 作为开发者&#xff0c;Linux是我们必须掌握的操作系统之一。因此&#xff0c;在编写代码和部署应用程序时&#xff0c;熟练使用Linux命令非常重要。这些常用命令不得不会&#xff0c;掌握这些命令&#…
阅读更多...
c提高学习——指针作为函数参数的输入特性

c提高学习——指针作为函数参数的输入特性

输入特性 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> //在主调函数分配内存 被调函数使用 void func(char *p) {strcpy(p, "hello world"); } void test01() {//在栈上分配内存char buf[1024] …
阅读更多...
《使用循环做一些练习》---C语言

《使用循环做一些练习》---C语言

目录 前言&#xff1a; 1.练习专题 1.1打印1-100之间的奇数 1.2计算n的阶乘 1.3计算到达n阶乘的前m个阶乘相加 1.4演示字符串动态变化的效果 2.goto语句 ❤博主CSDN:啊苏要学习 ▶专栏分类&#xff1a;C语言◀ C语言的学习&#xff0c;是为我们今后学习其它语言打好基础…
阅读更多...
扬声器，打印机2键触摸VK3602K SOP8 2键2通道触摸检测芯片技术资料直接输出自动校准功能

扬声器，打印机2键触摸VK3602K SOP8 2键2通道触摸检测芯片技术资料直接输出自动校准功能

型号&#xff1a;VK3602K 封装形式&#xff1a;SOP8 KPP2620 VK3602K具有2个触摸按键&#xff0c;可用来检测外部触摸按键上人手的触摸动作。该芯片具有较高的集成度&#xff0c;仅需极少的外部组件便可实现触摸按键的检测。 提供了2路直接输出功能,可通过IO脚选择输出电平。…
阅读更多...
基于单片机的家庭防盗报警系统的设计与实现_kaic

基于单片机的家庭防盗报警系统的设计与实现_kaic

基于单片机的家庭防盗报警系统 专业&#xff1a;物联网工程 摘要&#xff1a;本论文研究的是将AT89C52单片机芯片作为核心元器件的防盗报警系统,该系统除了具有直接报警的功能外,还额外增加了布防和红外感应的功能。和市场上的其他各类防盗报警器相比,该设计的不同之处在于它所…
阅读更多...
KubeSphere 助力提升研发效能的应用实践分享

KubeSphere 助力提升研发效能的应用实践分享

作者&#xff1a;卢运强&#xff0c;主要从事 Java、Python 和 Golang 相关的开发工作。热爱学习和使用新技术&#xff1b;有着十分强烈的代码洁癖&#xff1b;喜欢重构代码&#xff0c;善于分析和解决问题。原文链接。 我司从 2022 年 6 月开始使用 KubeSphere&#xff0c;到目…
阅读更多...
开放原子训练营（第一季）铜锁探密:基于铜锁构建在线在线加密工具箱

开放原子训练营（第一季）铜锁探密:基于铜锁构建在线在线加密工具箱

基于铜锁构建Web在线加密工具库 搭建运行环境 实验⼿册中的实验都是以 docker 和 docker-compose 环境为主&#xff0c;基于 Ubuntu 20.04 容器镜像。 初始化项目 首先利用 IDE 创建一个 tongsuo_web 的空项目&#xff0c;接下来我们所有的文件都会创建在该项目中&#xff0…
阅读更多...
AI如何帮助人类进而验证直觉的可靠性？

AI如何帮助人类进而验证直觉的可靠性？

AI可以通过以下方式帮助人类寻找反例进行否定或寻找特别的架构&#xff1a; 1. 利用机器学习算法进行反例搜索。AI可以训练一个分类器&#xff0c;用于判断某个假设是否成立。通过反复训练和测试&#xff0c;AI可以识别出一些不合理的假设&#xff0c;并帮助人类进行进一步的验…
阅读更多...
docker安装-顺利的安装docker--再也不烦心啦

docker安装-顺利的安装docker--再也不烦心啦

centos7安装Docker全过程记录&#xff08;无坑版教程&#xff09; 一、安装前必读 在安装 Docker 之前&#xff0c;先说一下配置&#xff0c;我这里是Centos7 Linux 内核&#xff1a;官方建议 3.10 以上&#xff0c;3.8以上貌似也可。 注意&#xff1a;本文的命令使用的是 r…
阅读更多...
004 鸿蒙应用开发-通知栏

004 鸿蒙应用开发-通知栏

目录 一.通知概述 通知简介 通知业务流程 广播的类型 接口说明 开发前期准备 二.发送普通文本类型通知 1.先初始化广播的请求request 2.然后发送广播 3.显示效果如下 三.发送长文本类型广播 1.构建发送广播的参数request 2.然后发送广播 3.显示效果如下 注意事项…
阅读更多...
利用ArcGIS软件赋予tif影像空间参考坐标系

利用ArcGIS软件赋予tif影像空间参考坐标系

问题&#xff1a; 在处理数据时有一幅没有任何空间参考坐标信息的tif影像&#xff0c;实质上为一个照片。现在需要将其与一个有空间地理参考坐标信息的shp文件叠加在一起。如何解决这个问题呢&#xff1f; 已知信息&#xff1a; shp文件的空间地理参考 shp文件的边界与tif影像的…
阅读更多...
CV中的注意力机制

CV中的注意力机制

注意力机制 计算机视觉中的注意力机制的基本思想 就是想让系统学会注意力 &#xff0c;能够忽略无关信息&#xff0c;关注重点信息。 1. 硬注意力机制&#xff08;Hard/Local Attention&#xff09; 对每个输入项分配的权重非0即1&#xff0c;和软注意不同&#xff0c;硬注…
阅读更多...
Sentence Bert 阅读笔记

Sentence Bert 阅读笔记

Sentence Bert 阅读笔记 论文 https://arxiv.org/abs/1908.10084 Supervised / Unsupervised / Semi-supervised 从训练上看&#xff0c;是 Supervised / Unsupervised 两种结合 Model Structure 本文提出了两个architecture&#xff0c;一个用于文本的分类&#xff0c;一…
阅读更多...
【Python基础绘图】自定义函数，一键标注相关性热力图的显著性

【Python基础绘图】自定义函数，一键标注相关性热力图的显著性

相关性热力图标自动注显著性 01 引言 很早之前其实就写过一篇博客【python相关性热力图自动标记显著性】介绍如何在相关性热力图上自动标注显著性&#xff0c;不过收到好多同学私信问我数据源是啥样的&#xff0c;怎么计算的啊等等问题。所以今天打算重新写篇&#xff0c;并附…
阅读更多...
【github开源】Linux iptables 界面化 分布式 管理平台 go vue，底座firewalld

【github开源】Linux iptables 界面化 分布式 管理平台 go vue，底座firewalld

快速部署&#xff1a;Uranus 目前最优的firewalld前端 如果你觉得项目符合你的使用场景, 劳烦大佬点个 &#x1f31f;&#x1f31f;&#x1f31f; 吧!!! 好人一生平安!!! Uranus Gateway Uranus使命是将iptables转化为类安全组功能的一个工具 Uranus Gateway 是一个分布式管…
阅读更多...
Android Studio添加EasyPemissions

Android Studio添加EasyPemissions

问题描述 按照EasyPermissions主页描述的那样添加完依赖后&#xff0c; 在程序中使用还是报错&#xff1a; Failed to resolve: pub.devrel:easypermissions:0.3.0 解决方法 首先&#xff0c;EasyPemissions属于别人的开源库&#xff0c;我们想使用的话&#xff0c;必须让…
阅读更多...
RHCE(shell第二次）

RHCE(shell第二次）

1.编写脚本for1.sh,使用for循环创建20账户&#xff0c;账户名前缀由用户从键盘输入&#xff0c;账户初始密码由用户输入&#xff0c;例如: test1、test2、test3、.....、 test10 创建脚本for1 [rootserver ~]# vim xixi.sh 测试 2.编写脚本for2.sh,使用for循环,通过ping命令测…
阅读更多...
中创AI|政治、工作、娱乐，ChatGPT正逐步影响我们的社会生产生活！

中创AI|政治、工作、娱乐，ChatGPT正逐步影响我们的社会生产生活！

“作为政策官员&#xff0c;我们所做的一切&#xff0c;无论是编写会议记录还是批准预算文件&#xff0c;只是为了调动资源来解决一个常见问题。一旦我们从这个角度看待自己&#xff0c;ChatGPT就会成为推动者&#xff0c;而不是破坏者。” ——新加坡政府官员 ChatGPT可被广…
阅读更多...
LC-1105. 填充书架（记忆化搜索 ==＞ 动态规划）

LC-1105. 填充书架（记忆化搜索 ==＞ 动态规划）

1105. 填充书架 难度中等169 给定一个数组 books &#xff0c;其中 books[i] [thicknessi, heighti] 表示第 i 本书的厚度和高度。你也会得到一个整数 shelfWidth 。 按顺序 将这些书摆放到总宽度为 shelfWidth 的书架上。 先选几本书放在书架上&#xff08;它们的厚度之和…
阅读更多...
ajax写法和json的知识点

ajax写法和json的知识点

1. JQuery方式来实现AJAX 1.1 $.ajax()方式来实现AJAX 语法&#xff1a;$.ajax(url,[settings]);但是我们一般这么写$.ajax({键值对});。 $.ajax()来实现ajax的案例&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023