求点集中最近点对--期望线性法

已于 2022-11-23 20:00:29 修改
阅读量199 收藏
点赞数
分类专栏： 小功能 轮子 文章标签： 算法 c++
于 2022-11-21 18:45:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/random_repick/article/details/127970189
版权
  • 参考这里最下面
  • n是1200左右时，和暴力解法耗时差不多
  • n越大，期望线性法越高效
  • n=99999时，暴力需要58秒，期望线性法需要小于1秒
  • n=307200时，暴力需要548秒，期望线性法需要5秒左右
  • CPU：Intel® Core™ i7-9700 CPU @ 3.00GHz
  • 期望线性法的最坏情况，即每次都重新划分，在n=9999时需要39秒
  • 20221123：加了分治，需要注意的是函数rec中的pt数组，n=99999时，如果使用vector，需要4.94秒，如果使用普通数组，需要0.07秒。因为vector的数据在堆上，普通数组的数据在栈上，访问栈比堆快得多，而且普通数组数据连续，cache命中率高。同时因为普通数组的数据在栈上导致数组太大会段错误，所以将普通数组放在静态区，访问静态区同样比堆快得多。
  • 20221123新版本：增加了保存所有最近点对
#include <unordered_map>
#include <vector>
#include <set>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <sys/time.h>
#define EPS 1e-3

using namespace std;

struct lwd {
    int i1;
    int i2;
};
struct cmp {
    bool operator() (const lwd &l1, const lwd &l2) {
        if(l1.i1 == l2.i1) return l1.i2 < l2.i2;
        return l1.i1 < l2.i1;
    }
};
vector<lwd> res,  res2;
set<lwd, cmp> res1;

void simple(vector<int> p1, vector<int> p2, int &a, int &b)
{
    int n = p1.size(), index = 0;
    double p10 = p1[0], p11 = p1[1], p20 = p2[0], p21 = p2[1];
    double dis = (p10 - p11) * (p10 - p11) + (p20 - p21) * (p20 - p21);
    dis = sqrt(dis);
    a = 0, b = 1;
    for (int i = 0; i < n; ++i)
    {
        for (int j = i + 1; j < n; ++j)
        {
            double p1i = p1[i], p1j = p1[j], p2i = p2[i], p2j = p2[j];
            double tmp = (p1i - p1j) * (p1i - p1j) + (p2i - p2j) * (p2i - p2j);
            tmp = sqrt(tmp);
            if(tmp > dis) continue;
            if (tmp < dis)
            {
                dis = tmp;
                a = i;
                b = j;
                res.clear();
            }
            lwd lwl;
            lwl.i1 = i;
            lwl.i2 = j;
            res.emplace_back(lwl);
        }
    }
}

/***************************************  分治  *******************************************/

struct pt
{
    int x, y, id;
};

struct cmpx
{
    bool operator()(const pt &a, const pt &b) const
    {
        return a.x < b.x || (a.x == b.x && a.y < b.y);
    }
} cmp_x;

struct cmpy
{
    bool operator()(const pt &a, const pt &b) const { return a.y < b.y; }
} cmp_y;

// vector<pt> vp;
double mindist;
int ansa, ansb;

inline void upd_ans(const pt &a, const pt &b)
{
    double ax = a.x, bx = b.x, ay = a.y, by = b.y;
    double dist = sqrt((ax - bx) * (ax - bx) + (ay - by) * (ay - by));
    if(dist > mindist) return;
    if (dist < mindist){
        mindist = dist, ansa = a.id, ansb = b.id;
        res1.clear();
    }
    lwd lwl;
    lwl.i1 = a.id;
    lwl.i2 = b.id;
    if(a.id > b.id) {
        lwl.i2 = a.id;
        lwl.i1 = b.id;
    }
    res1.insert(lwl);
}

void rec(vector<pt> &vp, int l, int r)
{
    if (r - l <= 3)
    {
        for (int i = l; i <= r; ++i)
            for (int j = i + 1; j <= r; ++j)
                upd_ans(vp[i], vp[j]);
        sort(vp.begin() + l, vp.begin() + r + 1, cmp_y);
        return;
    }

    int m = (l + r) >> 1;
    int midx = vp[m].x;
    rec(vp, l, m), rec(vp, m + 1, r);
    inplace_merge(vp.begin() + l, vp.begin() + m + 1, vp.begin() + r + 1, cmp_y);

    // vector<pt> t(vp.size());
    static pt t[100000];
    int tsz = 0;
    for (int i = l; i <= r; ++i)
        if (abs(vp[i].x - midx) <= mindist)
        {
            t[tsz++] = vp[i];
        }
    for(int i = 0; i < tsz; ++i) {
        for(int j = i+1; j < tsz && t[i].y-t[j].y <= mindist; ++j) {
            upd_ans(t[i], t[j]);
        }
    }
}

/***************************************  期望线性法  *******************************************/
// p1,p2是坐标数组，a,b是最近点对的索引
void linear(vector<int> p1, vector<int> p2, int &a, int &b)
{
    int n = p1.size(), mi1 = p1[0], ma1 = p1[0], mi2 = p2[0], ma2 = p2[0];
    // 求点的范围
    for (int i = 1; i < n; ++i)
    {
        if (mi1 > p1[i])
            mi1 = p1[i];
        if (ma1 < p1[i])
            ma1 = p1[i];
        if (mi2 > p2[i])
            mi2 = p2[i];
        if (ma2 < p2[i])
            ma2 = p2[i];
    }
    int d1 = ma1 - mi1, d2 = ma2 - mi2;
    // 以前两点的距离划分网格
    a = 0, b = 1;
    double p10 = p1[0], p11 = p1[1], p20 = p2[0], p21 = p2[1];
    double s = (p10 - p11) * (p10 - p11) + (p20 - p21) * (p20 - p21);
    s = sqrt(s);
    double ss = s + EPS;
    int s1 = d1 / ss + 1, s2 = d2 / ss + 1;
    // 将前两点放入对应网格
    unordered_map<int, vector<int>> um;
    for (int i = 0; i < 2; ++i)
    {
        int x = (p1[i] - mi1) / ss, y = (p2[i] - mi2) / ss;
        um[y * s1 + x].emplace_back(i);
    }
    lwd lwl;
    lwl.i1 = 0, lwl.i2 = 1;
    res2.emplace_back(lwl);
    // 依次处理剩余点：计算该点与周围九个网格点的最小距离，小于当前划分值则重新划分
    for (int i = 2; i < n; ++i)
    {
        // 当前点所在网格
        int x = (p1[i] - mi1) / ss, y = (p2[i] - mi2) / ss;
        // 周围九个网格与当前点的最小距离
        double tmp = s;
        // 周围九个网格与当前点最近的点的索引
        int aa = -1;
        // 周围九个网格
        for (int ii = y - 1; ii <= y + 1; ++ii)
        {
            if (ii < 0 || ii >= s2)
                continue;
            for (int jj = x - 1; jj <= x + 1; ++jj)
            {
                if (jj < 0 || jj >= s1)
                    continue;
                // 当前网格的点集,都是i之前的点
                vector<int> vv = um[ii * s1 + jj];
                for (int kk = 0; kk < vv.size(); ++kk)
                {
                    double p1i = p1[i], p1v = p1[vv[kk]], p2i = p2[i], p2v = p2[vv[kk]];
                    double dis = (p1i - p1v) * (p1i - p1v) + (p2i - p2v) * (p2i - p2v);
                    dis = sqrt(dis);
                    if(dis > tmp) continue;
                    if (dis < tmp)
                    {
                        tmp = dis;
                        aa = vv[kk];
                        res2.clear();
                    }
                    lwd lwl;
                    lwl.i1 = vv[kk];
                    lwl.i2 = i;
                    res2.emplace_back(lwl);
                }
            }
        }
        // 重新划分：更新划分值，最近点对，划分结果
        if (tmp < s)
        {
            s = tmp;
            ss = s + EPS;
            a = aa, b = i;
            s1 = d1 / ss + 1, s2 = d2 / ss + 1;
            um.clear();
            for (int ii = 0; ii < i; ++ii)
            {
                int xx = (p1[ii] - mi1) / ss, yy = (p2[ii] - mi2) / ss;
                um[yy * s1 + xx].emplace_back(ii);
            }
        }
        um[y * s1 + x].emplace_back(i);
    }
}

int main(int argc, char **argv)
{
    srand((unsigned)time(NULL));
    int n = stoi(argv[1]);
    vector<int> p1(n), p2(n);
    for (int i = 0; i < n; ++i)
    {
        p1[i] = rand() % n;
        p2[i] = rand() % n;
    }
    // 期望线性法的最好情况
    // p1[0] = p1[1] = p1[2] = 0, p2[0] = p2[1] = p2[2] = 0;
    // for(int i = 3; i < n; ++i) {
    //     p1[i] = p1[i-1]+i;
    //     p2[i] = p2[i-1]+i;
    // }
    // 期望线性法的最坏情况
    // for(int l = 0, r = n-1; l < r; ++l, --r) {
    //     int tmp = p1[l];
    //     p1[l] = p1[r];
    //     p1[r] = tmp;
    //     tmp = p2[l];
    //     p2[l] = p2[r];
    //     p2[r] = tmp;
    // }
    // for(int i = 0; i < n; ++i) cout << p1[i] << "  " << p2[i] << endl;
    int a = -1, b = -1;
    // 暴力解法耗时和结果
    struct timeval start, end;
    gettimeofday(&start, NULL);
    simple(p1, p2, a, b);
    gettimeofday(&end, NULL);
    float cost_time = (end.tv_usec - start.tv_usec) / 1000000.0 + end.tv_sec - start.tv_sec;
    cout << cost_time << endl;
    //cout << a << "  " << b << endl;
    //cout << p1[a] << "," << p2[a] << "\t" << p1[b] << "," << p2[b] << endl;
    cout << res.size() << endl;
    for(int i = 0; i < res.size(); ++i) {
        cout << res[i].i1 << "  " << res[i].i2 << endl;
        cout << p1[res[i].i1] << "," << p2[res[i].i1] << "\t" << p1[res[i].i2] << "," << p2[res[i].i2] << endl;
    }
    cout << "******************************\n";
    // 期望线性解法
    gettimeofday(&start, NULL);
    linear(p1, p2, a, b);
    gettimeofday(&end, NULL);
    cost_time = (end.tv_usec - start.tv_usec) / 1000000.0 + end.tv_sec - start.tv_sec;
    cout << cost_time << endl;
    // cout << a << "  " << b << endl;
    // cout << p1[a] << "," << p2[a] << "\t" << p1[b] << "," << p2[b] << endl;
    cout << res2.size() << endl;
    for(int i = 0; i < res2.size(); ++i) {
        cout << res2[i].i1 << "  " << res2[i].i2 << endl;
        cout << p1[res2[i].i1] << "," << p2[res2[i].i1] << "\t" << p1[res2[i].i2] << "," << p2[res2[i].i2] << endl;
    }
    cout << "******************************\n";
    // 分治
    vector<pt> vp;
    pt ppt;
    for (int i = 0; i < n; ++i)
    {
        ppt.x = p1[i];
        ppt.y = p2[i];
        ppt.id = i;
        vp.emplace_back(ppt);
    }
    gettimeofday(&start, NULL);
    sort(vp.begin(), vp.begin() + n, cmp_x);
    mindist = 1E20;
    rec(vp, 0, n - 1);
    gettimeofday(&end, NULL);
    cost_time = (end.tv_usec - start.tv_usec) / 1000000.0 + end.tv_sec - start.tv_sec;
    cout << cost_time << endl;
    // cout << ansa << "  " << ansb << endl;
    // cout << p1[ansa] << "," << p2[ansa] << "\t" << p1[ansb] << "," << p2[ansb] << endl;
    cout << res1.size() << endl;
    for(lwd l : res1) {
        cout << l.i1 << "  " << l.i2 << endl;
        cout << p1[l.i1] << "," << p2[l.i1] << "\t" << p1[l.i2] << "," << p2[l.i2] << endl;
    }
    cout << "******************************\n";

    return 0;
}
  • 以下是旧版本，期望线性法存在问题：s为零会出问题，和参考不一致
#include <unordered_map>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <sys/time.h>

using namespace std;

void simple(vector<int> p1, vector<int> p2, int &a, int &b)
{
    int n = p1.size();
    double dis = n * 2.2;
    for (int i = 0; i < n; ++i)
    {
        for (int j = i + 1; j < n; ++j)
        {
            double p1i = p1[i], p1j = p1[j], p2i = p2[i], p2j = p2[j];
            double tmp = (p1i - p1j) * (p1i - p1j) + (p2i - p2j) * (p2i - p2j);
            tmp = sqrt(tmp);
            if (tmp < dis)
            {
                dis = tmp;
                a = i;
                b = j;
            }
        }
    }
}

/***************************************  分治  *******************************************/

struct pt
{
    int x, y, id;
};

struct cmpx
{
    bool operator()(const pt &a, const pt &b) const
    {
        return a.x < b.x || (a.x == b.x && a.y < b.y);
    }
} cmp_x;

struct cmpy
{
    bool operator()(const pt &a, const pt &b) const { return a.y < b.y; }
} cmp_y;

// vector<pt> vp;
double mindist;
int ansa, ansb;

inline void upd_ans(const pt &a, const pt &b)
{
    double ax = a.x, bx = b.x, ay = a.y, by = b.y;
    double dist = sqrt((ax - bx) * (ax - bx) + (ay - by) * (ay - by));
    if (dist < mindist)
        mindist = dist, ansa = a.id, ansb = b.id;
}

void rec(vector<pt> &vp, int l, int r)
{
    if (r - l <= 3)
    {
        for (int i = l; i <= r; ++i)
            for (int j = i + 1; j <= r; ++j)
                upd_ans(vp[i], vp[j]);
        sort(vp.begin() + l, vp.begin() + r + 1, cmp_y);
        return;
    }

    int m = (l + r) >> 1;
    int midx = vp[m].x;
    rec(vp, l, m), rec(vp, m + 1, r);
    inplace_merge(vp.begin() + l, vp.begin() + m + 1, vp.begin() + r + 1, cmp_y);

    // vector<pt> t(vp.size());
    static pt t[100000];
    int tsz = 0;
    for (int i = l; i <= r; ++i)
        if (abs(vp[i].x - midx) < mindist)
        {
            t[tsz++] = vp[i];
        }
    for(int i = 0; i < tsz; ++i) {
        for(int j = i+1; j < tsz && t[i].y-t[j].y < mindist; ++j) {
            upd_ans(t[i], t[j]);
        }
    }
}

/***************************************  期望线性法  *******************************************/
// p1,p2是坐标数组，a,b是最近点对的索引
void linear(vector<int> p1, vector<int> p2, int &a, int &b)
{
    int n = p1.size(), mi1 = p1[0], ma1 = p1[0], mi2 = p2[0], ma2 = p2[0];
    // 求点的范围
    for (int i = 1; i < n; ++i)
    {
        if (mi1 > p1[i])
            mi1 = p1[i];
        if (ma1 < p1[i])
            ma1 = p1[i];
        if (mi2 > p2[i])
            mi2 = p2[i];
        if (ma2 < p2[i])
            ma2 = p2[i];
    }
    int d1 = ma1 - mi1, d2 = ma2 - mi2;
    // 以前两点的距离划分网格
    a = 0, b = 1;
    double p10 = p1[0], p11 = p1[1], p20 = p2[0], p21 = p2[1];
    double s = (p10 - p11) * (p10 - p11) + (p20 - p21) * (p20 - p21);
    s = sqrt(s);
    int s1 = d1 / s + 1, s2 = d2 / s + 1;
    // 将每个点放入对应网格
    unordered_map<int, vector<int>> um;
    for (int i = 0; i < n; ++i)
    {
        int x = (p1[i] - mi1) / s, y = (p2[i] - mi2) / s;
        um[y * s1 + x].emplace_back(i);
    }
    // 依次处理剩余点：计算该点与周围九个网格点的最小距离，小于当前划分值则重新划分
    for (int i = 2; i < n; ++i)
    {
        // 当前点所在网格
        int x = (p1[i] - mi1) / s, y = (p2[i] - mi2) / s;
        // 周围九个网格与当前点的最小距离
        double tmp = n * 2.2;
        // 周围九个网格与当前点最近的点的索引
        int aa = -1;
        // 周围九个网格
        for (int ii = y - 1; ii <= y + 1; ++ii)
        {
            if (ii < 0 || ii >= s2)
                continue;
            for (int jj = x - 1; jj <= x + 1; ++jj)
            {
                if (jj < 0 || jj >= s1)
                    continue;
                // 当前网格的点集
                vector<int> vv = um[ii * s1 + jj];
                for (int kk = 0; kk < vv.size(); ++kk)
                {
                    if (vv[kk] <= i && vv[kk] > 1)
                        continue;
                    double p1i = p1[i], p1v = p1[vv[kk]], p2i = p2[i], p2v = p2[vv[kk]];
                    double dis = (p1i - p1v) * (p1i - p1v) + (p2i - p2v) * (p2i - p2v);
                    dis = sqrt(dis);
                    if (dis < tmp)
                    {
                        tmp = dis;
                        aa = vv[kk];
                    }
                }
            }
        }
        // 重新划分：更新划分值，最近点对，划分结果
        if (tmp < s)
        {
            s = tmp;
            a = i, b = aa;
            s1 = d1 / s + 1, s2 = d2 / s + 1;
            um.clear();
            for (int ii = 0; ii < n; ++ii)
            {
                int xx = (p1[ii] - mi1) / s, yy = (p2[ii] - mi2) / s;
                um[yy * s1 + xx].emplace_back(ii);
            }
        }
    }
}

int main(int argc, char **argv)
{
    srand((unsigned)time(NULL));
    int n = stoi(argv[1]);
    vector<int> p1(n), p2(n);
    for (int i = 0; i < n; ++i)
    {
        p1[i] = rand() % n;
        p2[i] = rand() % n;
    }
    // 期望线性法的最好情况
    // p1[0] = 0, p2[0] = 0;
    // for(int i = 1; i < n; ++i) {
    //     p1[i] = p1[i-1]+i;
    //     p2[i] = p2[i-1]+i;
    // }
    // 期望线性法的最坏情况
    // for(int l = 0, r = n-1; l < r; ++l, --r) {
    //     int tmp = p1[l];
    //     p1[l] = p1[r];
    //     p1[r] = tmp;
    //     tmp = p2[l];
    //     p2[l] = p2[r];
    //     p2[r] = tmp;
    // }
    // for(int i = 0; i < n; ++i) cout << p1[i] << "  " << p2[i] << endl;
    int a = -1, b = -1;
    // 暴力解法耗时和结果
    struct timeval start, end;
    gettimeofday(&start, NULL);
    simple(p1, p2, a, b);
    gettimeofday(&end, NULL);
    float cost_time = (end.tv_usec - start.tv_usec) / 1000000.0 + end.tv_sec - start.tv_sec;
    cout << cost_time << endl;
    cout << a << "  " << b << endl;
    cout << p1[a] << "," << p2[a] << "\t" << p1[b] << "," << p2[b] << endl;
    // 期望线性解法
    gettimeofday(&start, NULL);
    linear(p1, p2, a, b);
    gettimeofday(&end, NULL);
    cost_time = (end.tv_usec - start.tv_usec) / 1000000.0 + end.tv_sec - start.tv_sec;
    cout << cost_time << endl;
    cout << a << "  " << b << endl;
    cout << p1[a] << "," << p2[a] << "\t" << p1[b] << "," << p2[b] << endl;
    // 分治
    vector<pt> vp;
    pt ppt;
    for (int i = 0; i < n; ++i)
    {
        ppt.x = p1[i];
        ppt.y = p2[i];
        ppt.id = i;
        vp.emplace_back(ppt);
    }
    gettimeofday(&start, NULL);
    sort(vp.begin(), vp.begin() + n, cmp_x);
    mindist = 1E20;
    rec(vp, 0, n - 1);
    gettimeofday(&end, NULL);
    cost_time = (end.tv_usec - start.tv_usec) / 1000000.0 + end.tv_sec - start.tv_sec;
    cout << cost_time << endl;
    cout << ansa << "  " << ansb << endl;
    cout << p1[ansa] << "," << p2[ansa] << "\t" << p1[ansb] << "," << p2[ansb] << endl;

    return 0;
}
刀么克瑟拉莫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
平面最近点对问题求解
一个不知名码农的专栏
07-25 8583
平面最近点对问题求解问题描述： 最近点对问题是指求解平面点集n个点中距离最近的两个点间的问题。为简单起见，在二维坐标平面来考虑该问题。如果说讨论的点以标准二维坐标给出，则有点和,那么这两点之间的距离。通过这个公式，我们可以计算平面上任意两点之间的距离。 本章主要通过两种方法来求解 蛮力法 分治法 1.蛮力法顾名思义，蛮力法指的就是通过遍历所有解之后通过对比求出最近点对问题。 基本思路： 对
matlab开发-加权和加权线性
08-23
在描述中提到的不同标准差的数据点，意味着数据集中的各个点可能具有不同的噪声水平。在拟合这样的数据时，加权处理变得至关重要。通常，我们可以将标准差作为权重的倒数，因为这会使得误差较大的点（即标准差较大的...
《算法导论》拓展之 一维二维最近点对问题
Toby的博客
05-30 660
本文为《算法导论》拓展之 一维二维最近点对问题，欢迎学习！
点集中的最近点 最远点对
Creek Shi
10-29 3431
点集中的最近点 http://www.cnblogs.com/king1302217/archive/2010/07/08/1773413.html 2、分治法      1）算法描述：已知集合S中有n个点，分治法的思想就是将S进行拆分，分为2部分求最近点对。算法每次选择一条垂线L，将S拆分左右两部分为SL和SR，L一般取点集S中所有点的中间点的x坐标来划分，这样可以保证SL
平面内有N个点，如何快速求出距离最近的点对？
算法channel
10-16 6667
大家好，我们今天来看一道非常非常经典的算法题——最近点对问题。这个问题经常在各种面试当中出现，难度不低，很少有人能答上来。说实话，我也被问过，因为毫无准备，所以也没有答上来。是的，这道题...
scikit-learn学习系列 - 广义线性模型
杰径通幽
03-01 2749
下面是一组用于回归的方法，其中目标值是输入变量的线性组合。在数学上，如果y^是预测值 在整个模块中，我们指定向量 w=(w1,...,wp)ascoef_andw0asintercept_. 使用广义线性模型进行分类，见Logistic regression. 1. 普通最小二乘法 线性回归适用于带有系数w=(w1,...,wp)的线性模型，最小化数据集中观测响应与线性...
机器人动力学方程（一）：牛顿-欧拉法
05-17
在牛顿-欧拉法中，首先对机器人的基座进行分析，得到基座的动力学方程，然后依次对每个关节进行分析。对于每个关节i，动力学方程可表示为： M_i * q̈_i + C_i * q̇_i + G_i = τ_i 其中，M_i 是关节i的质量...
厦门大学--统计学试卷A（附参考答案）.pdf
08-24
【统计学知识点详解】 1. **不变标志**：在统计学中，不变标志是指在一定时期内不会发生变化的统计特征，如企业的产业分类。在考察全国企业情况时，产业分类通常是一个固定不变的属性。 2. **调查单位**：在人口...
MK_mannkendall_manner-kendall(m-k)_K._m-k检验法_Mk非参数检验_
09-29
M-K检验的核心在于S统计量和T统计量的计算，其中S统计量是所有数据对秩差的和，而T统计量则是在假设无趋势时S的期望值。 计算S后，需要对其进行标准化，得到Z统计量，以确定趋势的显著性。Z统计量通常与标准正态...
算法-顺序统计量
04-03
在这个主题下，我们将深入探讨顺序统计量、其算法实现以及与期望线性和最坏线性复杂度相关的知识。 顺序统计量，通常表示为STOQ（Sequential k-th Order Statistic），指的是在未排序的数据集合中，通过一次遍历找...
C++实现按空格暂停，按任意键继续，按ESC退出
random_repick的专栏
06-16 4314
借助opencv实现 #include<opencv2/opencv.hpp> using namespace cv; int key = waitKey(10) & 0xff; if(key == 32) { waitKey(0); } if(key == 27) { return; }
linux记录某个程序的内存和CPU占用
random_repick的专栏
09-07 2841
mem.sh #!/bin/bash process=$1 pid=$(ps -e|grep $process| grep -v 'grep' | awk '{print $1;}') while true do mem=`cat /proc/$pid/status|grep -e VmRSS` cpu=`top -n 1 -p $pid|tail -3|head -1|awk '{ssd=NF-4} {print $ssd}'` echo $(date +"%y-%m-%d-%H:%M.
ubuntu C++ 获取当前系统时间
random_repick的专栏
10-21 2611
#include <stdio.h> #include <time.h> std::string getCurrentTimeStr(){ time_t t = time(NULL); char ch[64] = {0}; char result[100] = {0}; strftime(ch, sizeof(ch) - 1, "%Y%m%d--%H%M%...
21种颜色的rgb值及显示
random_repick的专栏
11-02 1732
#include <opencv2/opencv.hpp> int colors[21][3] = { {255, 0, 0}, {255, 69, 0}, {255, 99, 71}, {255, 140, 0}, {255, 165, 0}, {238, 173, 14}, {255, 193, 37}, {255, 255, 0}, .
求点集的最小面积外接矩形
random_repick的专栏
12-17 1556
求点集的最小面积外接矩形 void Rotate(float& x, float& y, float angle) { float a = x * cos(angle) - y * sin(angle); float b = x * sin(angle) + y * cos(angle); x = a; y = b; } void Rect(const vecto...
opencv摄像头异常处理
random_repick的专栏
07-28 1466
摄像头打开失败 摄像头中途拔插，掉电 cv::VideoCapture capture(camera_id_); cv::Mat frame; while (!capture.isOpened()) { ROS_INFO("%s open fail!", camera_id_.c_str()); sleep(3); capture.open(camera_id_); } while (ros::ok()) { capture >> frame; if .
C++、python从路径中提取文件名
random_repick的专栏
07-13 1328
string getPicName(string path) { int l = path.length(); int i; for(i = l-1; i >=0; i--) { if(path[i] == '/') break; } return path.substr(i+1, l-i-1); }
python使用鼠标在图片上画框
最新发布
random_repick的专栏
09-05 1302
【代码】python在图片上画框。
python直接在RGB调整饱和度，亮度，对比度
random_repick的专栏
07-10 1170
【代码】python直接在RGB调整饱和度，亮度，对比度。
Dialectica范畴中的自然数对象探析
文章作者指出，80年代后期的范畴证明理论研究催生了对吉拉德线性逻辑的辩证法解释，并且最近对线性逻辑系统的辩证解释有了进展。然而，尚未将这些概念扩展到系统T。本文旨在开始探索自然数对象在原始辩证法范畴解释...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刀么克瑟拉莫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值