csp资料

头文件
#include <bits/stdc++.h>
using namespace std
isdigit(c);
isalpha(c);
switch(type){
	case value : 操作
}
continue;//结束本轮循环
break;//结束所在的整个循环

tips:
//除法变乘法来算
//减法变加法
num=1e4+2;//"1e4"表示10的4次方

//用于移除容器中相邻的重复元素。它会将重复元素移动到容器末尾，并返回一个指向不重复序列末尾的迭代器
 // 使用 std::unique 移除相邻的重复元素
std::vector<int>::iterator last = std::unique(vec.begin(), vec.end());
//last指向最后一个不重复元素之后的位置
// 删除移动到末尾的重复元素
vec.erase(last, vec.end());
数学
#include <algorithm>
min(a, b); max(a, b); 
swap(a, b);

//sort(begin,end)
//默认升序，降序或者对于自定义的数据类型，要自定义排序方法
//数组
int arr[] = {3, 1, 4, 1, 5};
int size = sizeof(arr) / sizeof(arr[0]);
std::sort(arr, arr + size);
//vector
vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
sort(numbers.begin(), numbers.end()); // 对 numbers 进行升序排序

//对于自定义的数据类型，要自己定义排序函数
struct Score {
	int y;
	int result;
};
bool cmp(Score a, Score b){
	return a.y < b.y;
	//小于为真，升序排列
	//这种是稳定的
}
vector<Score> S;
sort(S.begin(), S.end(), cmp);//升序排列

// 使用 std::stable_sort 对向量进行稳定排序
stable_sort(vec.begin(), vec.end());
数学
#include <cmath>
pow(2, 3);//3次方
abs(num);//绝对值

//绝对值函数：
abs()//返回整数的绝对值
labs()//返回长整型的绝对值
fabs()//返回浮点数的绝对值

//取整函数：
ceil()//向上取整
floor()// 向下取整
round()// 四舍五入

//指数和对数函数：
exp()//计算 e 的幂次方
log()//自然对数
log10()//以 10 为底的对数

//三角函数：
sin(), cos(), tan()// 正弦、余弦、正切
asin(), acos(), atan()://反正弦、反余弦、反正切

//幂运算和平方根：
pow()//幂函数
sqrt()// 平方根

//其他常见函数：
fmod()// 求模（取余）
modf()//分解整数与小数部分
// 使用 modf() 分解整数与小数部分
    double input = 123.45;
    double intPart;
    double fracPart = std::modf(input, &intPart);
isnan()//判断是否为非数值（NaN）
向量
#include <vector>
push_back(element)：向 vector 尾部添加一个元素。
pop_back()：删除 vector 尾部的元素。
size()：返回 vector 中元素的个数。
empty()：检查 vector 是否为空，返回布尔值。
clear()：清空 vector 中的所有元素。
at(index)：返回指定索引位置的元素，会进行边界检查。
front()：返回 vector 的第一个元素。
back()：返回 vector 的最后一个元素。
begin() 和 end()：返回指向第一个元素和尾后元素的迭代器，用于遍历整个 vector。
insert(iterator, element)：在指定位置插入一个元素。
erase(iterator)：删除指定位置的元素。
resize(new_size)：改变 vector 的大小，如果新大小比当前大小大，则填充默认值；如果新大小比当前大小小，则删除多余元素。

vector<int> T(2,0);//初始化为全0
vector<vector<int> > T(n,vector<int>(2,0));
map
#include <map>
map<KeyType, ValueType> myMap;
//加入
myMap[key] = value;
//删除
myMap.erase(key);

检查键是否存在
if (myMap.count(key) > 0) {
    // 键存在
}

auto it = myMap.find(key);
if (it != myMap.end()) {
    // 键存在
}
//size：返回 map 中键-值对的数量
int size = myMap.size();

//clear：清空 map 中的所有元素
myMap.clear();

// 使用 insert 方法合并， map2 合并到map1
map1.insert(map2.begin(), map2.end());
//遍历
for (auto it = myMap.begin(); it != myMap.end(); ++it) {
    cout << it->first << " : " << it->second << endl;
    //访问键和值
    it->first
    it->second
}
//std::map 是基于红黑树实现的关联容器，它要求键是有序的，因此在插入、查找和删除元素时需要进行键的比较。默认情况下，对于内置类型的键，std::map 使用 < 运算符来进行比较；而对于自定义类型的键，则需要通过重载运算符来定义比较规则。
// 自定义类型，重载，遍历
class Point {
	public:
		int x;
		int y;
		bool operator == (const Point& other) const {
			return (x == other.x) && (y == other.y);
		}
		bool operator < (const Point& other) const {
			if(x == other.x) {
				return y < other.y;
			}
			return x < other.x;
		}
};

for (map<Point, int>::iterator it = points.begin(); it != points.end(); ++it)
map
//insert：插入元素到 set 中。
set<int> mySet;
mySet.insert(10);

//erase：从 set 中删除指定元素。
mySet.erase(10);

//find：查找指定元素，返回指向该元素的迭代器
auto it = mySet.find(20);
if (it != mySet.end()) {
    // 找到元素
} else {
    // 未找到元素
}

//count：计算 set 中某个值的出现次数（由于 set 中元素唯一，因此返回值只能是 0 或 1）
int occurrences = mySet.count(20);

//size：返回 set 中元素的数量
int size = mySet.size();

//empty：检查 set 是否为空
if (mySet.empty()) {
    // set 为空
} else {
    // set 不为空
}

//clear：清空 set 中的所有元素
mySet.clear();

//lower_bound 和 upper_bound：在有序集合中执行二分查找操作
auto lower = mySet.lower_bound(15); // 返回第一个不小于 15 的元素的迭代器
auto upper = mySet.upper_bound(25); // 返回第一个大于 25 的元素的迭代器

//begin 和 end：返回指向第一个和最后一个元素的迭代器，用于遍历 set
for (auto it = mySet.begin(); it != mySet.end(); ++it) {
    // 使用 *it 访问元素值
}
控制输出格式
#include <iomanip>
cout << fixed << setprecision(3) << ans;
栈
#include <stack>
stack<int> s;
s.push(5);  // 将元素 5 压入栈顶
s.pop();    // 弹出栈顶元素
if (!s.empty()) {
    int topElement = s.top();  // 获取栈顶元素
}
矩阵运算

矩阵运算的话，一般都往顺序上想想，复杂度会降。
复杂度和矩阵的规模有关系，[i,k] X [k,j] 复杂度 = i * k *j
然后矩阵的运算是三层循环，i，j，k，前两层一个是左行，一个是右列，k是控制每行每列的的每一个
正常：ans[i][j] += Q[i][k] * t[k][j];
转置：ans[i][j] += Q[k][i] * t[k][j]; （行列互换）

对象数组
class Tree{
	public:
		int flag = 0;//是否发生掉落 
		int sum;//果总数 
};
vector<Tree> Trees;

Tree newtree;
cin >> newtree.sum;
Trees.push_back(newtree);
// 循环数组
if(Trees[((i-1) + N) % N].flag && Trees[((i+1) + N) % N].flag)

稳定的排序

//冒泡排序
void bubbleSort(std::vector<int>& arr) {
    int n = arr.size();
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                std::swap(arr[j], arr[j+1]);
            }
        }
    }
}
// 插入排序
void insertionSort(std::vector<int>& arr) {
    int n = arr.size();
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i-1;
        while (j >= 0 && arr[j] > key) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}
//归并排序
void merge(std::vector<int>& arr, int l, int m, int r) {
    int n1 = m-l+1;
    int n2 = r-m;

    std::vector<int> L(n1), R(n2);

    for (int i = 0; i < n1; i++) {
        L[i] = arr[l+i];
    }
    for (int j = 0; j < n2; j++) {
        R[j] = arr[m+1+j];
    }

    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k++] = L[i++];
        } else {
            arr[k++] = R[j++];
        }
    }
    while (i < n1) {
        arr[k++] = L[i++];
    }
    while (j < n2) {
        arr[k++] = R[j++];
    }
}

void mergeSort(std::vector<int>& arr, int l, int r) {
    if (l < r) {
        int m = l + (r-l)/2;
        mergeSort(arr, l, m);
        mergeSort(arr, m+1, r);
        merge(arr, l, m, r);
    }
}
二维前缀和

在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include <vector>
using namespace std;

int main() {
	int n, L, r, t;
	cin >> n >> L >> r >> t;
	vector<vector<int> > prefix(n + 1, vector<int>(n + 1, 0));//初始化为全0，从下标为1的位置存储 前缀和 
//	vector<int> prefix(n, 0);
	int temp = 0; 
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= n; j++){
			cin >> temp;
			prefix[i][j] = prefix[i - 1][j] + prefix[i][j - 1] - prefix[i - 1][j - 1] + temp;
		}
	}
	int sum, ans = 0;
	int x1,y1,x2,y2;
    for(int i = 1; i <= n; i++){
    	for(int j = 1; j <= n; j++){
    		x1 = max(1, i - r);
    		y1 = max(1, j - r);
    		x2 = min(n, i + r);
    		y2 = min(n, j + r);
    		sum = prefix[x2][y2] - prefix[x2][y1 - 1] - prefix[x1 - 1][y2] + prefix[x1 - 1][y1 - 1];
    		if((x2 - x1 + 1) * (y2 - y1 + 1) * t >= sum) ans++;
		}
	}
	cout << ans << endl;
	return 0;
}
区间分段

区间分段a[i], a[i+1] )时f(x) = i ；当它在[ kr, (k+1)r )时，g(x) = k；

#include<iostream>
#include<algorithm>
using namespace std;
 
const int M=1e5;
int A[M];
 
int main(){
	int n,N;
	cin>>n>>N;
	A[0]=0;
	int r=N/(n+1);
	for(int i=1;i<=n;i++){
		cin >> A[i];		
	}
	A[++n]=N;//处理最后一段A[n]到N-1
	long long res=0;//注意res必须为long long否则溢出出错
	int f=0;
	int left,mid,right;
 
	for(int i=1;i<=n;i++){//分大段，每次走到f+1的位置
		left=A[i-1];
		right=A[i]-1;//注意要-1
 
		if((left/r)!=(right/r)){//该大段内有多个g值
			for(mid=left+(r-left%r-1);mid<=right;mid+=r){//分小段，每次走到g+1的位置
				res+=abs((left/r-f)*(mid-left+1));//mid前为旧g，mid后为新g
				left=mid+1;
			}
			res+=abs((right/r-f)*(right-left+1));//处理最后一小段
		}
		else{//该大段g相同，不用分小段
			res+=abs((left/r-f)*(right-left+1));
		}
		f++;
	}
	cout<<res;
	return 0;
}
差分数组

在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 4e5+10;

int main()
{
	int n,m,k;
	int b[N];//差分数组
    cin >> n >> m >> k;
    int t, c;
    for(int i = 1; i <= n; i++)
    {
        cin >> t >> c;
        int left = t - c + 1;//定义左边界
        left = left > 0 ? left : 1;
        int right = t;//定义右边界
		//left ~ right之间的数都+1
		b[left]++;
		b[right+1]--;
    }
    //前缀和操作，得到各个点的数值
    for(int i = 1; i <= N; i++){
        b[i] = b[i-1] + b[i];
    }
    while(m--)
    {
        int x;
        cin >> x;
        cout << b[x+k] << endl;//直接得到x+k处的数值
    }
    return 0;
}
岛屿问题
/* CCF202109-2 非零段划分 */
//1、差分法（先消去相邻重复元素，再从unique后的数组第一位到最后一位，依次比较数字与相邻数的大小，并对d操作） 
#include <bits/stdc++.h>
using namespace std;
const int maxn=5e5+2,num=1e4+2;
int a[maxn],d[num]={0};
int main(){
	int n;
	cin >> n;
	for(int i=1;i<=n;i++) cin>>a[i];
	a[0]=a[n+1]=0;
	int k=unique(a,a+n+2)-a-1;//k为序列去重后，最后一个元素（0）的数组下标 
	//unique(a, a+n+2) 返回的是一个指向去重后数组的新的"逻辑尾部"的指针，
	//然后通过减去 a 的地址，得到了去重后数组的长度。这样就可以得到去重后的数组的长度 k。
	/*
	想象成海平面问题，海平面一开始为num高，慢慢往下降的时候会有岛屿露出来
	如果第i个岛屿比他两边岛屿海拔都高 ,则降到a[i]高度时岛屿数量++
	如果第i个岛屿比他两边岛屿都低，则降到a[i]高度时，第i个岛屿将左右两边的岛屿连到一起，岛屿数量--
	如果第i个岛屿比他一边岛屿高，一边岛屿低，则降到a[i]时，岛屿数量不变 
	*/
	for(int i=1;i<k;i++){
		if(a[i]>a[i-1]&&a[i]>a[i+1]) d[a[i]]++;
		else if(a[i]<a[i-1]&&a[i]<a[i+1]) d[a[i]]--;
	}
	int res=0;int sum=0;
	//d[i]表示海平面降到i的高度时，岛屿数量的变化，从大到小求后缀和，后缀和最大即为结果 
	for(int i=num;i>=0;i--){
		sum+=d[i];
		res=max(res,sum);
	}
	cout<<res;
	return 0;
}
自定义多种优先级排序

在结构体中，根据题目意思，按照时间、类型、编号的先后顺序，分别对时间从小到大排序，先还后取，编号从小到大排序；

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;
const int N = 1e4+10;
int n,k;
struct node{
    int t;//记录时间
    int type;//记录操作类型，用0代表取钥匙，1代表还钥匙
    int id;//记录编号
    bool operator < (const node p)const{
        if(t!=p.t)return t<p.t;//首先判断时间，按照时间从小到大进行排序
        if(p.type!=type)return type>p.type;//再判断类型，按照还钥匙优先排序
        return id<p.id;//再判断编号，按照编号从小到大进行排序
    }
}p[N];
int q[N];
int main()
{
    cin>>n>>k;
    int id,start,len;
    int j=1;//记录结构体中有多少个元素，用于排序；
    for(int i=1;i<=n;i++)q[i]=i;//初始化钥匙盒
    for(int i=1;i<=k;i++)
    {
        cin>>id>>start>>len;
        p[j++]={start,0,id};//将取钥匙操作加入结构体
        p[j++]={start+len,1,id};//将还钥匙操作加入结构体，还钥匙时间为start+len
    }
    sort(p+1,p+j+1);//排序
    for(int i=1;i<=j;i++)
    {
        int  t =p[i].id;
        if(p[i].type==0)//取钥匙；
        {
            for(int k=1;k<=n;k++)//循环找到对应的钥匙号
            {
                if(q[k]==t)
                {
                    q[k]=0;
                    break;
                }
            }
        }
        else//放钥匙;
        {
            for(int k=1;k<=n;k++)//循环找到第一个空位置
            {
                if(q[k]==0)
                {
                    q[k]=t;
                    break;
                }
            }
        }
    }
    for(int i=1;i<=n;i++)cout<<q[i]<<" ";
    cout<<endl;
    return 0;
}
背包

在这里插入图片描述在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【面试专题】MySQL

【面试专题】MySQL

1.什么是BufferPool&#xff1f; Buffer Pool基本概念 Buffer Pool&#xff1a;缓冲池&#xff0c;简称BP。其作用是用来缓存表数据与索引数据&#xff0c;减少磁盘IO操作&#xff0c;提升效率。 Buffer Pool由缓存数据页(Page) 和 对缓存数据页进行描述的控制块 组成, 控制…
阅读更多...
鹏哥C语言复习——指针

鹏哥C语言复习——指针

目录 一.指针基础概念 二.指针和指针类型 三.野指针介绍 四.规避野指针的办法 五.指针运算 六.指针和数组 七.指针和数组传参 八.二级指针 九. 函数指针 十.qsort( )函数 十一.字符指针 一.指针基础概念 指针是什么&#xff1f; 指针理解的2个要点&#xff1a; 1.指…
阅读更多...
java内存分析工具visualvm

java内存分析工具visualvm

java内存分析工具visualvm 下载地址:https://visualvm.github.io/
阅读更多...
开源推荐榜【Taichi 专为高性能计算机图形学设计的编程语言】

开源推荐榜【Taichi 专为高性能计算机图形学设计的编程语言】

Taichi是一个高性能的并行编程语言&#xff0c;它被嵌入在Python中&#xff0c;使得开发者能够轻松编写可移植的、高性能的并行程序。这个库的核心优势在于它能够将计算密集型的Python代码在运行时通过即时编译器(Just-In-Time, JIT)转换成快速的机器代码&#xff0c;从而加速P…
阅读更多...
MT9630全制式Android智能商显解决方案

MT9630全制式Android智能商显解决方案

一、方案描述 商用显示通常是指专业显示器设备&#xff0c;可靠性和高清晰显示能力远强于普通显示器&#xff0c;在成像处理与色彩、亮度和对比度还有可视视角几方面具备优势&#xff0c;主要应用于商业场景&#xff0c;中国商业显示市场细分产品包括电子白板、商用电视、广告…
阅读更多...
012_control_flow_in_Matlab中的控制流

012_control_flow_in_Matlab中的控制流

Matlab中的控制流 虽然&#xff0c;我们说Matlab中的计算是向量化的&#xff0c;但是在某些情况下&#xff0c;作为一个“程序设计语言”&#xff0c;Matlab也提供了一些控制流结构&#xff0c;来帮助我们实现一些复杂的逻辑。 我会在介绍控制流的时候&#xff0c;提醒如何用…
阅读更多...
大数据学习-2024/3/30-MySQL5.6版本的安装

大数据学习-2024/3/30-MySQL5.6版本的安装

1、下载好文件后打开bin目录&#xff1a; 2、在这个位置进入输入cmd进入命令行界面&#xff0c;进入命令行界面后输入如下&#xff1a;mysqld install 进行数据库安装&#xff1a; 注意&#xff1a;显示Service successfully installed表示安装成功 3、安装好后启动服务&…
阅读更多...
通过mapreduce程序统计旅游订单（wordcount升级版）

通过mapreduce程序统计旅游订单（wordcount升级版）

通过mapreduce程序统计旅游订单&#xff08;wordcount升级版&#xff09; 本文将结合一个实际的MapReduce程序案例&#xff0c;探讨如何通过分析旅游产品的预订数据来揭示消费者的偏好。 程序概览 首先&#xff0c;让我们来看一下这个MapReduce程序的核心代码。这个程序的目…
阅读更多...
上门家政按摩H5小程序源码

上门家政按摩H5小程序源码

《服务器环境配置》 1、服务器环境&#xff1a;CentOS7 宝塔 Nginx php 2、环境&#xff1a;PHP7.2 MySQL5.6 3、安装扩展&#xff1a;fileinfo、redis 《程序安装配置》 1、新建站点及数据库&#xff0c;然后申请创建SSL证书&#xff0c;配置到站点&#xff0c;开启强…
阅读更多...
GT20L16S1Y标准汉字字库芯片完全解析（3）

GT20L16S1Y标准汉字字库芯片完全解析（3）

接前一篇文章&#xff1a;GT20L16S1Y标准汉字字库芯片完全解析&#xff08;2&#xff09; 本文内容参考&#xff1a; 字库芯片GT20L16S1Y使用记录-CSDN博客 GT20L16S1Y字库IC驱动_gt20l16s1y字库芯片测试程序-CSDN博客 《GT20L16S1Y 标准点阵汉字库芯片产品规格书 V4.0I_K 2…
阅读更多...
信息工程大学第五届超越杯程序设计竞赛 题解

信息工程大学第五届超越杯程序设计竞赛 题解

信息工程大学第五届超越杯程序设计竞赛 \huge{信息工程大学第五届超越杯程序设计竞赛} 信息工程大学第五届超越杯程序设计竞赛 写在前面 本篇题解按照题目难易顺序进行排序 大致难易顺序为&#xff1a;A<M<F<D<C<E<G<K<H<B<I<J A. 遗失的…
阅读更多...
PCL点云处理之 基于垂直度检测与距离聚类 的路面点云提取方案 （二百三十九）

PCL点云处理之 基于垂直度检测与距离聚类 的路面点云提取方案 （二百三十九）

PCL点云处理之 基于垂直度检测与距离聚类 的路面点云提取方案 （二百三十九） 一、算法流程二、具体步骤1.垂直度检测与渲染1.代码2.效果2.水平分布点云提取1.代码2.效果3.路面连通点云提取1.代码2.效果三、完整代码四、参考文献一、算法流程
阅读更多...
开发指南020-banner

开发指南020-banner

<dependency><groupId>org.qlm</groupId><artifactId>qlm-common</artifactId><version>1.0-SNAPSHOT</version> </dependency> 以上组件封装了平台的banner&#xff0c;不做任何配置的话&#xff0c;将输出平台的banner 想修…
阅读更多...
如何过得更幸福？我推荐你读这5本书

如何过得更幸福？我推荐你读这5本书

快乐不等于幸福。快乐是一种短暂的体验&#xff0c;随着多巴胺的消退而迅速减退。快乐是有捷径的&#xff0c;那就是戏弄相关的神经回路。 幸福是有意义、有目的和积极的生活的持久体验。 今天&#xff0c;为大家推荐一份“幸福书单”。 01 《幸福的勇气》 岸见一郎、古贺史…
阅读更多...
【Linux实践室】Linux用户管理实战指南：用户权限切换操作详解

【Linux实践室】Linux用户管理实战指南：用户权限切换操作详解

&#x1f308;个人主页&#xff1a;聆风吟_ &#x1f525;系列专栏&#xff1a;Linux实践室、网络奇遇记 &#x1f516;少年有梦不应止于心动&#xff0c;更要付诸行动。 文章目录 一. ⛳️任务描述二. ⛳️相关知识2.1 &#x1f514;图形化界面登录2.2 &#x1f514;使用login…
阅读更多...
OSCP靶场--Twiggy

OSCP靶场--Twiggy

OSCP靶场–Twiggy 考点(CVE-2020-11651[RCE]) 1.nmap扫描 ## ┌──(root㉿kali)-[~/Desktop] └─# nmap 192.168.216.62 -sV -sC -Pn --min-rate 2500 -p- Starting Nmap 7.92 ( https://nmap.org ) at 2024-03-30 06:43 EDT Nmap scan report for 192.168.216.62 Host i…
阅读更多...
2024蓝旭春季第二次前端培训课

2024蓝旭春季第二次前端培训课

目录 CSS伪类与伪元素 伪类 伪元素 关系选择器 分类举例 后代选择器 子元素选择器 相邻兄弟选择器 通用兄弟选择器 作用使用场景 后代选择器&#xff08;空格&#xff09; 子元素选择器 (>) 相邻兄弟选择器 () 通用兄弟选择器 (~) 随机提问 CSS布局 基础布局…
阅读更多...
群晖配置FTP服务结合内网穿透实现公网访问本地NAS中储存文件

群晖配置FTP服务结合内网穿透实现公网访问本地NAS中储存文件

文章目录 1. 群晖安装Cpolar2. 创建FTP公网地址3. 开启群晖FTP服务4. 群晖FTP远程连接5. 固定FTP公网地址6. 固定FTP地址连接 本文主要介绍如何在群晖NAS中开启FTP服务并结合cpolar内网穿透工具&#xff0c;实现使用固定公网地址远程访问群晖FTP服务实现文件上传下载。 Cpolar内…
阅读更多...
服务器监控软件夜莺采集监控（三）

服务器监控软件夜莺采集监控（三）

文章目录 一、采集器插件1. exec插件2. rabbitmq插件3. elasticsearch插件 二、监控仪表盘1. 系统信息2. 数据服务3. NginxMQ4. Docker5. 业务日志 一、采集器插件 1. exec插件 input.exec/exec.toml [[instances]] commands ["/home/monitor/categraf/scripts/*.sh&q…
阅读更多...
GEE23：基于植被物候实现农作物分类

GEE23：基于植被物候实现农作物分类

地物分类 1. 写在前面2. 北京作物分类 1. 写在前面 今天分享一个有意思的文章&#xff0c;用于进行农作物分类。文章提出了一个灵活的物候辅助监督水稻(PSPR)制图框架。主要是通过提取植被物候&#xff0c;并自动对物候数据进行采样&#xff0c;获得足够多的样本点&#xff0c;…
阅读更多...
最新文章

Copyright @ 2022~2023