4.7总结

对于之前学过有关集合的东西感觉忘记了很多，重新学了一下泛型的知识

+补题（今天的测试一塌糊涂）

泛型

泛型有泛型类和泛型方法

泛型在不同的地方定义有不同的名称

类后面	泛型类
方法上面	泛型方法
接口后面	泛型接口

泛型类

一般在一个类中，某个数据的数据类型不确定时，就可以定义带带有泛型的类

格式：

修饰符 class 类名 <类型>{}

举例：

public class Arraylist <E>

泛型方法

方法中形参类型不确定时我们有两种方法来定义泛型方法

1：使用类名后面定义的泛型（所有方法都能使用）

2：在方法申明上定义自己的泛型（只有本方法能用）

格式：

修饰符 <类型> 返回值类型 方法名 （类型 变量名）{}

举例：

public <T> void show (T t){}

值得注意的是泛型不具备继承性，但是数据具备继承性

即不同类型多次调用时泛型类型与第一个传入的类型相同，之后不再发生改变

泛型的通配符

？表示不确定的类型，也可以进行类型的限定

？ extends E:表示可以传递E或者所有的子类类型

? super E:表示可以传递E或者E所有的父类类型

爬虫

与正则表达式关系密切

正则表达式有两个作用：

1：校验字符串是否满足规则

2：在一段文本中查找满足要求的内容

爬虫可以根据预先制定好的规则获取网页（或其他文本）中想要得到的数据

Pattern 表示正则表达式

Matcher 表示文本匹配器，按照正则表达式的规则去读取字符串，从头开始读取，在大串中去找符合匹配规则的子串

根据不同的需求使用不同的预定义字符串或者数量词、字符类从而得到想要的数据

D - 逆序对

Description

猫猫 TOM 和小老鼠 JERRY 最近又较量上了，但是毕竟都是成年人，他们已经不喜欢再玩那种你追我赶的游戏，现在他们喜欢玩统计。

最近，TOM 老猫查阅到一个人类称之为“逆序对”的东西，这东西是这样定义的：对于给定的一段正整数序列，逆序对就是序列中 ��>��ai​>aj​ 且 �<�i<j 的有序对。知道这概念后，他们就比赛谁先算出给定的一段正整数序列中逆序对的数目。注意序列中可能有重复数字。

Update:数据已加强。

（可以尝试用学的树状数组进行求解逆序对）线段树当然也可以，树状数组代码少一点

Input

第一行，一个数 n，表示序列中有 n个数。

第二行 n 个数，表示给定的序列。序列中每个数字不超过 109。

Output

输出序列中逆序对的数目。

Sample 1

Inputcopy	Outputcopy
6 5 4 2 6 3 1	11

Hint

对于 25% 的数据，n≤2500

对于 50% 的数据，n≤4×10^4。

对于所有数据，n≤5×10^5

请使用较快的输入输出

应该不会 O(n^2) 过 50 万吧 by chen_zhe

思路：最开始使用树状数组的方法一直过不去，后面索性使用归并排序来写，将整个数组分为左右两个部分，左部分和右部分都从最左边开始，依次匹配，逆序对要求就是ai>aj且i<j,只要左右部分的指向没有指向同一下标，一直进行递归，每次函数调用时根据不同的情况把排好序的数字一个个从小到大放进一个空数组，逆序对计数结束后再将空数组依次赋值给原来的数组，最后进行输出即可

代码：

#include<stdio.h>
#include<iostream>
using namespace std;
int n, a[500010], c[500010];
long long ans;
void msort(int b, int e)//归并排序
{
    if (b == e)
        return;
    int mid = (b + e) / 2, i = b, j = mid + 1, k = b;
    msort(b, mid), msort(mid + 1, e);
    while (i <= mid && j <= e)
        if (a[i] <= a[j])
            c[k++] = a[i++];
        else
            c[k++] = a[j++], ans += mid - i + 1;//统计答案
    while (i <= mid)
        c[k++] = a[i++];
    while (j <= e)
        c[k++] = a[j++];
    for (int l = b; l <= e; l++)
        a[l] = c[l];
}
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    msort(1, n);
    cout << ans << endl;
    return 0;
}

第三次测试（补题） - Virtual Judge (vjudge.net)

开了平方根还用int,被两个double卡了一个多小时，在一个简单题上浪费了这么多时间，下次不能再犯

#include<algorithm>
#include<iostream>
#include<math.h>
using namespace std;
struct node {
	int x;
	int y;
	double d;
	int dd;
}e[100000];
int main()
{
	int n, i, j;
	cin >> n;
	for (i = 1; i <= n; i++)
	{
		cin >> e[i].x >> e[i].y;
		e[i].d = 0;
		e[i].dd = i;
	}
	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= n; j++)
		{
			double a = sqrt((e[i].x - e[j].x) * (e[i].x - e[j].x) + (e[i].y - e[j].y) * (e[i].y - e[j].y));
			if (a > e[i].d)
			{
				e[i].dd = j;
				e[i].d = a;
			}
		}
	}
	for (i = 1; i <= n; i++)
	{
		cout << e[i].dd << endl;
	}

}

第三次测试（补题） - Virtual Judge (vjudge.net)

思路：利用map数组操作，把每个c[i]存入map中，将所有map[c[i]]赋值为1e9，用一次循环来将其与a[i]对比使map[c[i]]的值最小，最后将map[]进行遍历得到的就是每个颜色下的最小值，这些最小值中的最大值就是问题的答案

#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
typedef long long ll;
const int maxn = 1e6;
ll ans;
ll a[maxn];
string c[maxn];
void solve()
{
	map<string, ll>mmp;
	ll n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i] >> c[i];
		mmp[c[i]] = 1e9;
	}
	for (int i = 1; i <= n; i++)
	{
		if (mmp[c[i]] > a[i])
		{
			mmp[c[i]] = a[i];
		}
	}
	ll mx = -1;
	for (int i = 1; i <= n; i++)
	{
		mx = max(mx, mmp[c[i]]);
	}
	cout << mx << endl;
	return;
}
int main()
{
	int t = 1;
	while (t--)
		solve();
	return 0;
}