2021-07-18 TOYS

已于 2023-02-17 14:55:54 修改
阅读量174 收藏
点赞数
分类专栏： 南昌理工学院ACM集训队 文章标签： 算法
于 2021-07-18 09:17:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45892201/article/details/118873217
版权

TOYS

题目链接
题意：
有一个矩形盒子，放入n块按照x轴排序的不相交的隔板，这样就将矩形盒子分成了n+1块区域。现在将m个玩具放入这个矩形盒子，统计每个区域的玩具个数。

思路：
利用叉乘的性质判断在当前隔板的左边还是右边，由于每个玩具在隔板的左边或右边具有单调性，所以可以二分优化

ac代码：

枚举+二分O(mlogn)

#include <iostream>  
#include <stdio.h>  
#include <string.h>   
#include <stack>  
#include <queue>   
#include <map>  
#include <set>  
#include <vector>  
#include <math.h>  
#include <bitset>  
#include <algorithm>  
#include <climits>

using namespace std;
// `计算几何模板`
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
const int maxp = 1010;
//`Compares a double to zero`
int sgn(double x){
	if(fabs(x) < eps)return 0;
	if(x < 0)return -1;
	else return 1;
}
//square of a double
inline double sqr(double x){return x*x;}

struct Point{
	double x,y;
	Point(){}
	Point(double _x,double _y){
		x = _x;
		y = _y;
	}
	void input(){
		scanf("%lf%lf",&x,&y);
	}
	void output(){
		printf("%.2f %.2f\n",x,y);
	}
	bool operator == (Point b)const{
		return sgn(x-b.x) == 0 && sgn(y-b.y) == 0;
	}
	bool operator < (Point b)const{
		return sgn(x-b.x)== 0?sgn(y-b.y)<0:x<b.x;
	}
	Point operator -(const Point &b)const{
		return Point(x-b.x,y-b.y);
	}
	//叉积
	double operator ^(const Point &b)const{
		return x*b.y - y*b.x;
	}
	//点积
	double operator *(const Point &b)const{
		return x*b.x + y*b.y;
	}
	//返回长度
	double len(){
		return hypot(x,y);//库函数
	}
	//返回长度的平方
	double len2(){
		return x*x + y*y;
	}
	//返回两点的距离
	double distance(Point p){
		return hypot(x-p.x,y-p.y);
	}
	Point operator +(const Point &b)const{
		return Point(x+b.x,y+b.y);
	}
	Point operator *(const double &k)const{
		return Point(x*k,y*k);
	}
	Point operator /(const double &k)const{
		return Point(x/k,y/k);
	}
	//`计算pa  和  pb 的夹角`
	//`就是求这个点看a,b 所成的夹角`
	//`测试 LightOJ1203`
	double rad(Point a,Point b){
		Point p = *this;
		return fabs(atan2( fabs((a-p)^(b-p)),(a-p)*(b-p) ));
	}
	//`化为长度为r的向量`
	Point trunc(double r){
		double l = len();
		if(!sgn(l))return *this;
		r /= l;
		return Point(x*r,y*r);
	}
	//`逆时针旋转90度`
	Point rotleft(){
		return Point(-y,x);
	}
	//`顺时针旋转90度`
	Point rotright(){
		return Point(y,-x);
	}
	//`绕着p点逆时针旋转angle`
	Point rotate(Point p,double angle){
		Point v = (*this) - p;
		double c = cos(angle), s = sin(angle);
		return Point(p.x + v.x*c - v.y*s,p.y + v.x*s + v.y*c);
	}
};

const int N = 5010;
Point U[N], L[N];
int cnt[N];

bool check(Point a, Point b) {
    return sgn(a ^ b) == 1;
}

int main() {
    int n, m, x1, y1, x2, y2;
    while (scanf("%d", &n), n) {
        memset(cnt, 0, sizeof cnt);
        scanf("%d %d %d %d %d", &m, &x1, &y1, &x2, &y2);
        for (int i = 1; i <= n; ++ i) {
            int a, b;
            scanf("%d %d", &a, &b);
            U[i] = Point(a, y1), L[i] = Point(b, y2);
        }
        U[n + 1] = Point(x2, y1), L[n + 1] = Point(x2, y2);
        
        for (int i = 1; i <= m; ++ i) {
            int x, y;
            scanf("%d %d", &x, &y);
            
            int l = 1, r = n + 1, mid, ans;
            while (l <= r) {
                mid = l + r >> 1;
                if (check(U[mid] - L[mid], Point(x, y) - L[mid])) 
                    ans = mid, r = mid - 1;
                else l = mid + 1;
            }
            
            cnt[ans - 1] ++ ;
        }
        
        for (int i = 1; i <= n + 1; ++ i) {
        	printf("%d: %d\n", i - 1, cnt[i - 1]);
		}
		printf("\n");
    }
    return 0;
}

暴力枚举O(n*m)

#include <iostream>  
#include <stdio.h>  
#include <string.h>   
#include <stack>  
#include <queue>   
#include <map>  
#include <set>  
#include <vector>  
#include <math.h>  
#include <bitset>  
#include <algorithm>  
#include <climits>

using namespace std;
// `计算几何模板`
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
const int maxp = 1010;
//`Compares a double to zero`
int sgn(double x){
	if(fabs(x) < eps)return 0;
	if(x < 0)return -1;
	else return 1;
}
//square of a double
inline double sqr(double x){return x*x;}

struct Point{
	double x,y;
	Point(){}
	Point(double _x,double _y){
		x = _x;
		y = _y;
	}
	void input(){
		scanf("%lf%lf",&x,&y);
	}
	void output(){
		printf("%.2f %.2f\n",x,y);
	}
	bool operator == (Point b)const{
		return sgn(x-b.x) == 0 && sgn(y-b.y) == 0;
	}
	bool operator < (Point b)const{
		return sgn(x-b.x)== 0?sgn(y-b.y)<0:x<b.x;
	}
	Point operator -(const Point &b)const{
		return Point(x-b.x,y-b.y);
	}
	//叉积
	double operator ^(const Point &b)const{
		return x*b.y - y*b.x;
	}
	//点积
	double operator *(const Point &b)const{
		return x*b.x + y*b.y;
	}
	//返回长度
	double len(){
		return hypot(x,y);//库函数
	}
	//返回长度的平方
	double len2(){
		return x*x + y*y;
	}
	//返回两点的距离
	double distance(Point p){
		return hypot(x-p.x,y-p.y);
	}
	Point operator +(const Point &b)const{
		return Point(x+b.x,y+b.y);
	}
	Point operator *(const double &k)const{
		return Point(x*k,y*k);
	}
	Point operator /(const double &k)const{
		return Point(x/k,y/k);
	}
	//`计算pa  和  pb 的夹角`
	//`就是求这个点看a,b 所成的夹角`
	//`测试 LightOJ1203`
	double rad(Point a,Point b){
		Point p = *this;
		return fabs(atan2( fabs((a-p)^(b-p)),(a-p)*(b-p) ));
	}
	//`化为长度为r的向量`
	Point trunc(double r){
		double l = len();
		if(!sgn(l))return *this;
		r /= l;
		return Point(x*r,y*r);
	}
	//`逆时针旋转90度`
	Point rotleft(){
		return Point(-y,x);
	}
	//`顺时针旋转90度`
	Point rotright(){
		return Point(y,-x);
	}
	//`绕着p点逆时针旋转angle`
	Point rotate(Point p,double angle){
		Point v = (*this) - p;
		double c = cos(angle), s = sin(angle);
		return Point(p.x + v.x*c - v.y*s,p.y + v.x*s + v.y*c);
	}
};

const int N = 5010;
Point U[N], L[N];
int cnt[N];

int main() {
    int n, m, x1, y1, x2, y2;
    while (scanf("%d", &n), n) {
        memset(cnt, 0, sizeof cnt);
        scanf("%d %d %d %d %d", &m, &x1, &y1, &x2, &y2);
        for (int i = 1; i <= n; ++ i) {
            int a, b;
            scanf("%d %d", &a, &b);
            U[i] = Point(a, y1), L[i] = Point(b, y2);
        }
        
        for (int i = 1; i <= m; ++ i) {
            int x, y;
            scanf("%d %d", &x, &y);
            int j = 1;
            for (; j <= n; ++ j) {
                //U[j].output(), L[j].output();
                
                if (sgn((U[j] - L[j]) ^ (Point(x, y) - L[j])) == 1) {
					break;
				}
            }
            // cout << j << " ";
            // cout << endl;
            cnt[j - 1] ++ ;
        }
        
        for (int i = 1; i <= n + 1; ++ i) {
        	printf("%d: %d\n", i - 1, cnt[i - 1]);
		}
		printf("\n");
    }
    return 0;
}

Toy Storage

题意同上
区别这题直线未排序
排序+二分

#include <iostream>  
#include <stdio.h>  
#include <string.h>   
#include <stack>  
#include <queue>   
#include <map>  
#include <set>  
#include <vector>  
#include <math.h>  
#include <bitset>  
#include <algorithm>  
#include <climits>

using namespace std;
// `计算几何模板`
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
const int maxp = 1010;
//`Compares a double to zero`
int sgn(double x){
	if(fabs(x) < eps)return 0;
	if(x < 0)return -1;
	else return 1;
}
//square of a double
inline double sqr(double x){return x*x;}

struct Point{
	double x,y;
	Point(){}
	Point(double _x,double _y){
		x = _x;
		y = _y;
	}
	void input(){
		scanf("%lf%lf",&x,&y);
	}
	void output(){
		printf("%.2f %.2f\n",x,y);
	}
	bool operator == (Point b)const{
		return sgn(x-b.x) == 0 && sgn(y-b.y) == 0;
	}
	bool operator < (Point b)const{
		return sgn(x-b.x)== 0?sgn(y-b.y)<0:x<b.x;
	}
	Point operator -(const Point &b)const{
		return Point(x-b.x,y-b.y);
	}
	//叉积
	double operator ^(const Point &b)const{
		return x*b.y - y*b.x;
	}
	//点积
	double operator *(const Point &b)const{
		return x*b.x + y*b.y;
	}
	//返回长度
	double len(){
		return hypot(x,y);//库函数
	}
	//返回长度的平方
	double len2(){
		return x*x + y*y;
	}
	//返回两点的距离
	double distance(Point p){
		return hypot(x-p.x,y-p.y);
	}
	Point operator +(const Point &b)const{
		return Point(x+b.x,y+b.y);
	}
	Point operator *(const double &k)const{
		return Point(x*k,y*k);
	}
	Point operator /(const double &k)const{
		return Point(x/k,y/k);
	}
	//`计算pa  和  pb 的夹角`
	//`就是求这个点看a,b 所成的夹角`
	//`测试 LightOJ1203`
	double rad(Point a,Point b){
		Point p = *this;
		return fabs(atan2( fabs((a-p)^(b-p)),(a-p)*(b-p) ));
	}
	//`化为长度为r的向量`
	Point trunc(double r){
		double l = len();
		if(!sgn(l))return *this;
		r /= l;
		return Point(x*r,y*r);
	}
	//`逆时针旋转90度`
	Point rotleft(){
		return Point(-y,x);
	}
	//`顺时针旋转90度`
	Point rotright(){
		return Point(y,-x);
	}
	//`绕着p点逆时针旋转angle`
	Point rotate(Point p,double angle){
		Point v = (*this) - p;
		double c = cos(angle), s = sin(angle);
		return Point(p.x + v.x*c - v.y*s,p.y + v.x*s + v.y*c);
	}
};

struct Line{
    Point l, u;
//     Line(){}
// 	Line(Point _x,Point _y){
// 		l = _x;
// 		u = _y;
// 	}
    bool operator < (Line b) const{
        if (l == b.l) return u < b.u;
        return l < b.l;
    }
};

const int N = 5010;
Point U[N], L[N];
int cnt[N], qcnt[N];
Line LU[N];


bool check(Point a, Point b) {
    return sgn(a ^ b) == 1;
}

int main() {
    int n, m, x1, y1, x2, y2;
    while (scanf("%d", &n), n) {
        memset(cnt, 0, sizeof cnt);
        memset(qcnt, 0, sizeof qcnt);
        scanf("%d %d %d %d %d", &m, &x1, &y1, &x2, &y2);
        for (int i = 1; i <= n; ++ i) {
            int a, b;
            scanf("%d %d", &a, &b);
            U[i] = Point(a, y1), L[i] = Point(b, y2);
            LU[i - 1] = {L[i], U[i]};
        }
        U[n + 1] = Point(x2, y1), L[n + 1] = Point(x2, y2);
        LU[n] = {L[n + 1], U[n + 1]};
        sort(LU, LU + n);
        
        // for (int i = 0; i <= n; ++ i) {
        //     LU[i].l.output(), LU[i].u.output();
        // }
        // for (int i = 1; i <= m; ++ i) {
        //     int x, y;
        //     scanf("%d %d", &x, &y);
        // }
        
        //for (int i = 0; i <= n; ++ i) LU[i].l.output(), LU[i].u.output();
        
        for (int i = 1; i <= m; ++ i) {
            int x, y;
            scanf("%d %d", &x, &y);
            
            int l = 0, r = n, mid, ans;
            while (l <= r) {
                mid = l + r >> 1;
                Point a = LU[mid].u, b = LU[mid].l;
                if (check(a - b, Point(x, y) - b))
                //if (check(LU[mid].u - LU[mid].l, Point(x, y) - LU[mid]).l))
                    ans = mid, r = mid - 1;
                else l = mid + 1;
            }
            //cout << ans << endl;
            
            cnt[ans] ++ ;
        }
        
         for (int i = 0; i <= n; ++ i) {
        	qcnt[cnt[i]] ++ ;
        	//printf("%d: %d\n", i, cnt[i]);
		}
		printf("Box\n");
		for (int i = 1; i <= m; ++ i) {
			if (qcnt[i])
			printf("%d: %d\n", i, qcnt[i]);
		}
		//printf("\n");
    }
    return 0;
}

枚举暴力

#include <iostream>  
#include <stdio.h>  
#include <string.h>   
#include <stack>  
#include <queue>   
#include <map>  
#include <set>  
#include <vector>  
#include <math.h>  
#include <bitset>  
#include <algorithm>  
#include <climits>

using namespace std;
// `计算几何模板`
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
const int maxp = 1010;
//`Compares a double to zero`
int sgn(double x){
	if(fabs(x) < eps)return 0;
	if(x < 0)return -1;
	else return 1;
}
//square of a double
inline double sqr(double x){return x*x;}

struct Point{
	double x,y;
	Point(){}
	Point(double _x,double _y){
		x = _x;
		y = _y;
	}
	void input(){
		scanf("%lf%lf",&x,&y);
	}
	void output(){
		printf("%.2f %.2f\n",x,y);
	}
	bool operator == (Point b)const{
		return sgn(x-b.x) == 0 && sgn(y-b.y) == 0;
	}
	bool operator < (Point b)const{
		return sgn(x-b.x)== 0?sgn(y-b.y)<0:x<b.x;
	}
	Point operator -(const Point &b)const{
		return Point(x-b.x,y-b.y);
	}
	//叉积
	double operator ^(const Point &b)const{
		return x*b.y - y*b.x;
	}
	//点积
	double operator *(const Point &b)const{
		return x*b.x + y*b.y;
	}
	//返回长度
	double len(){
		return hypot(x,y);//库函数
	}
	//返回长度的平方
	double len2(){
		return x*x + y*y;
	}
	//返回两点的距离
	double distance(Point p){
		return hypot(x-p.x,y-p.y);
	}
	Point operator +(const Point &b)const{
		return Point(x+b.x,y+b.y);
	}
	Point operator *(const double &k)const{
		return Point(x*k,y*k);
	}
	Point operator /(const double &k)const{
		return Point(x/k,y/k);
	}
	//`计算pa  和  pb 的夹角`
	//`就是求这个点看a,b 所成的夹角`
	//`测试 LightOJ1203`
	double rad(Point a,Point b){
		Point p = *this;
		return fabs(atan2( fabs((a-p)^(b-p)),(a-p)*(b-p) ));
	}
	//`化为长度为r的向量`
	Point trunc(double r){
		double l = len();
		if(!sgn(l))return *this;
		r /= l;
		return Point(x*r,y*r);
	}
	//`逆时针旋转90度`
	Point rotleft(){
		return Point(-y,x);
	}
	//`顺时针旋转90度`
	Point rotright(){
		return Point(y,-x);
	}
	//`绕着p点逆时针旋转angle`
	Point rotate(Point p,double angle){
		Point v = (*this) - p;
		double c = cos(angle), s = sin(angle);
		return Point(p.x + v.x*c - v.y*s,p.y + v.x*s + v.y*c);
	}
};

const int N = 5010;
Point U[N], L[N];
int cnt[N], qcnt[N];

int main() {
    int n, m, x1, y1, x2, y2;
    while (scanf("%d", &n), n) {
        memset(cnt, 0, sizeof cnt);
        memset(qcnt, 0, sizeof qcnt);
        scanf("%d %d %d %d %d", &m, &x1, &y1, &x2, &y2);
        for (int i = 1; i <= n; ++ i) {
            int a, b;
            scanf("%d %d", &a, &b);
            U[i] = Point(a, y1), L[i] = Point(b, y2);
        }
        U[n + 1] = Point(x2, y1), L[n + 1] = Point(x2, y2);
        
        for (int i = 1; i <= m; ++ i) {
            int x, y;
            scanf("%d %d", &x, &y);
            int j = 1, ans;
            double minn = inf;
            for (; j <= n + 1; ++ j) {
                if (sgn((U[j] - L[j]) ^ (Point(x, y) - L[j])) == 1 
				&& sgn(minn - L[j].x) == 1) {
					ans = j;
					minn = L[j].x;
				}
            }
//             cout << ans << "\n";
//             cout << minn << " ";
//             cout << endl;
            cnt[ans - 1] ++ ;
        }
        
        for (int i = 1; i <= n + 1; ++ i) {
        	qcnt[cnt[i - 1]] ++ ;
        	//printf("%d: %d\n", i - 1, cnt[i - 1]);
		}
		printf("Box\n");
		for (int i = 1; i <= m; ++ i) {
			if (qcnt[i])
			printf("%d: %d\n", i, qcnt[i]);
		}
		//printf("\n");
    }
    return 0;
}
ziyou_zi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法训练|摆动序列(贪心算法)
weixin_45394002的博客
12-25 409
思路：给数组中的每一个元素设置一个状态，有begin,up,down三种状态，如果规定状态转换的位置成为【峰】和【谷】,那么，状态转换一次，则子序列的长度++，即【峰】和【谷】的总和就是子序列的长度。 代码: class Solution { public int wiggleMaxLength(int[] nums) { //如果数组的长度小于等于1的话，那么摆动序列的个数和数组元素的个数一致 if(nums.length<=1){ .
PowerToys-Chinese-TransMOD:PowerToys定制简体中文翻译补丁-PowerToys自制简中翻译优化包
04-01
PowerToys自定义简体中文翻译补丁 PowerToys自制简体中文翻译优化补丁根据我自己的使用习惯，修改了程序界面文本等要素，以界面简洁为目标，可能与原版文本上有出入。当前版本所有模块名称已修改为中文。汇报bug请用...
hlg1175小陈老师、桌子、盘子【计算几何】
weixin_30642267的博客
03-03 144
大意：一个R的桌子能否摆下n个半径为r的盘子 要求所有的盘子靠桌子的边缘放置 分析： 两种思路 一种是看这个桌子放这种盘子最多放多少个 一种是把这种盘子n个放在这个桌子上最少需要多大桌子半径 代码： 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> ...
桌子上有一个盘子,每次只能放一个水果.爸爸专门向盘子里放苹果,妈妈专门向盘子里放橘子,一个儿子专门等吃盘子中的橘子,一个女儿专门等吃盘子中的苹果.用信号量实现他们间的同步机制.
热门推荐
静无需言
06-22 6万+
题目: 桌子上有一个盘子,每次只能放一个水果.爸爸专门向盘子里放苹果,妈妈专门向盘子里放橘子,一个儿子专门等吃盘子中的橘子,一个女儿专门等吃盘子中的苹果.用信号量实现他们间的同步机制. 解:     1:盘子是临界资源.要实施互斥. 用信号量 f 表示.      2:苹果用 a 表示.  橘子用 o 表示.      3:盘子的状态(空,或者满) 用 e 表示.
（2021-07-14~）“kuangbin带你飞”专题计划——专题十三：基础计算几何
I_have_a_world的博客
07-14 258
前言 参考博客 自己总结的东西： 2021-07-10-计算几何总结 旋转卡壳&凸包（不用一下子就学完所有） 难度判断？ [kuangbin带你飞]专题十三 基础计算几何
PowerToys-master_materialny6_nan_PowerToys-master_powertoys_
10-03
powertoys 微软名为PowerToys的免费系统实用工具套件从Windows XP时代复活，并于2019年5月引入Windows 10系统。可以用于高级用户调整和简化 Windows 操作，以提高效率。通过 Windows 10 shell 使用，同时让用户可以...
map-toys
03-22
在“map-toys-master”这个压缩包文件中，"master"通常表示这是项目的主分支，可能包含了项目的源代码、资源文件、测试用例、README文档等。要了解这个项目具体实现的功能和工作原理，你需要解压文件并查看里面的...
Monitor Toys-开源
07-19
"Monitor Toys" 是一个开源项目，它允许用户利用像 GeekTool 和 Conky 这样的工具在他们的桌面上展示各种信息，以实现个性化和高效的桌面管理。这个项目旨在提供一种方式，让用户可以定制自己的桌面环境，使其更加...
Midi Toys-开源
05-09
Midi Toys是一款可将有趣的设备转变为Midi乐器的应用程序，到目前为止已实现的设备是wacom平板电脑和ps2风格的操纵杆。 乐器包括鼓机和搅拌机，还有更多后续产品
36. Adam 算法详解
qq_41238579的博客
07-10 959
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
函数模板与类模板
程序员_小兵
07-12 1545
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 693
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
【排序 - 堆排序】
2302_80393814的博客
07-10 544
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
最新发布
hanmo22357的博客
07-12 789
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 170
【代码】代码随想录算法训练营第33天。
力扣215 数组中第k大的数
东篱君的博客
07-10 294
算法：由于数组最大范围是10000，存在负数。申请一个20000的数组，将原数组的数作为新数组下标（+10000因为存在负数），然后从后往前减，求出第K大的数。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。本题主要考察各种排序算法，要求时间O（n），严格意义上说只有计数排序满足条件。给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树
wonderlandlja的博客
07-11 211
【代码】代码随想录算法训练营Day21 | 669. 修剪二叉搜索树 | 108.将有序数组转换为二叉搜索树 | 538.把二叉搜索树转换为累加树。
SMU Summer 2024 Contest Round 2
FS_tar的博客
07-09 476
本来想直接暴力k的，0——6，3的六次方有点太大了，可以循环每个即可，一个比较简单的模拟。N个产品，每个产品在T【i】时间持续D【i】秒经过打印机，可以接受打印，打印是一瞬间的事但打印完需要冷却一秒。n个长度为l【i】的单词，每个单词间隔一空，行首不用间隔，给定最多m行，求窗口最小宽度。对着这题目和题解得有将近四小时吧，看的还是很懵而且对着答案一直在改，给我改麻木了已经。给定长度为n的字符串s，q个询问，求在l到r的范围内有多少组俩个连续字符。给出数字k，每9个循环，中间镂空，具体输出见示例。
powertoyssetup-0.68
11-01
powertoyssetup-0.68 是一个软件安装程序，属于Windows PowerToys工具集的一部分。 Windows PowerToys是由微软官方开发的一套实用工具集，旨在增强Windows操作系统的功能和性能。这些工具通过提供额外的功能和快捷...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值