UVA572 Oil Deposits DFS求解

最新推荐文章于 2024-05-23 17:21:42 发布
最新推荐文章于 2024-05-23 17:21:42 发布
阅读量91 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/zjutzz/p/11017619.html
版权

小白书上经典DFS题目。

1. 递归实现

// from: https://www.cnblogs.com/huaszjh/p/4686092.html

#include <stdio.h>
#include <string.h>
#define maxn 105
unsigned char data[maxn][maxn];
int m, n, vis[maxn][maxn];

void dfs(int x, int y, int ans) {
    if (x < 0 || x >= m || y < 0 || y >= n) return; //出界
    if (vis[x][y] > 0 || data[x][y] == '*') return; //非'@'或已经访问
    vis[x][y] = ans; //连通分量编号
    for (int k = -1; k <= 1; k++) {
        for (int t = -1; t <= 1; t++) {
            if (k != 0 || t != 0) { //自身格子不需要重复判断
                dfs(x + k, y + t, ans);
            }
        }
    }
}

#define DEBUG
int main() {
#ifdef DEBUG
    const char* input_txt_pth = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
    freopen(input_txt_pth, "r", stdin);
#endif

    int i, j;
    while (scanf("%d %d", &m, &n) && m &&n) {
        int count = 0; //连通块
        memset(vis, 0, sizeof(vis));
        for (i = 0; i < m; i++) {
            scanf("%s", data[i]);
        }
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                //对未访问且为`@`的格子进行访问
                if (vis[i][j] == 0 && data[i][j] == '@') {
                    dfs(i, j, ++count);
                }
            }
        }
        printf("%d\n", count);
#ifdef DEBUG
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                printf("%3d", vis[i][j]);
            }
            printf("\n");
        }
        printf("\n");
#endif
    }
    return 0;
}

2. 递归dfs函数用迭代实现
每个节点的dfs递归调用，改成用stack容器就地计算，是个while循环，本质上还是栈，但是避免了递归时嵌套产生的开销造成的潜在风险。

C++的stack、vector容器用起来比较顺手。另外就是把坐标简单封装为一个结构体。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <stack>
#include <vector>

typedef struct Coord {
    char x, y;
} Coord;

#define DEBUG
int main() {
#ifdef DEBUG
    const char* input_txt_pth = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
    freopen(input_txt_pth, "r", stdin);
#endif

    int m, n, i, j;

    #define maxn 105
    unsigned char data[maxn][maxn];
    int vis[maxn][maxn];

    while (scanf("%d %d", &m, &n) && m &&n) {
        int count = 0; //连通块
        memset(vis, 0, sizeof(vis));
        for (i = 0; i < m; i++) {
            scanf("%s", data[i]);
        }

        std::stack<Coord> stk;
        Coord cd;
        std::vector<Coord>offset;
        cd.x = -1; cd.y = -1; offset.push_back(cd);
        cd.x = -1; cd.y = 0; offset.push_back(cd);
        cd.x = -1; cd.y = 1; offset.push_back(cd);
        cd.x = 0; cd.y = -1; offset.push_back(cd);
        cd.x = 0; cd.y = 1; offset.push_back(cd);
        cd.x = 1; cd.y = -1; offset.push_back(cd);
        cd.x = 1; cd.y = 0; offset.push_back(cd);
        cd.x = 1; cd.y = 1; offset.push_back(cd);

        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                cd.x = i; cd.y = j;
                if (vis[cd.x][cd.y] > 0 || data[cd.x][cd.y] != '@') continue;
                count++;

                stk.push(cd);
                while (!stk.empty()) {
                    cd = stk.top();
                    stk.pop();
                    vis[cd.x][cd.y] = count;

                    Coord tmp;
                    for (size_t k = 0; k < offset.size(); k++) {
                        tmp.x = cd.x + offset[k].x;
                        tmp.y = cd.y + offset[k].y;
                        if (tmp.x < 0 || tmp.x >= m || tmp.y < 0 || tmp.y >= n) continue;
                        if (vis[tmp.x][tmp.y] > 0 || data[tmp.x][tmp.y] != '@') continue;
                        stk.push(tmp);
                    }
                }
            }
        }

        printf("%d\n", count);

#ifdef DEBUG
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                printf("%3d", vis[i][j]);
            }
            printf("\n");
        }
        printf("\n");
#endif
    }
    return 0;
}

3.纯C，DFS非递归，自定义栈ADT，函数指针

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>

typedef struct Coord Coord;
struct Coord {
    char x, y;
};

typedef struct CoordOffset CoordOffset;
struct CoordOffset {
    size_t num;
    int* x;
    int* y;
};

typedef struct ListNode ListNode;
struct ListNode
{
    ListNode* next;
    void* data;
};

typedef struct Stack Stack;

struct Stack {
    ListNode* head;
    size_t len;
    void(*push_coord)(Stack* stk, Coord* coord);
    void (*pop_coord)(Stack* stk);
    void (*top_coord)(Stack* stk, Coord* coord);
};


void stack_push_coord(Stack* stk, Coord* coord) {
    ListNode* new_head = (ListNode*)malloc(sizeof(ListNode));
    /* new_head->data = coord; */
    new_head->data = (Coord*)malloc(sizeof(ListNode));
    memcpy(new_head->data, coord, sizeof(Coord));

    new_head->next = stk->head;
    stk->head = new_head;
    stk->len++;
}

void stack_pop_coord(Stack* stk) {
    if (stk->head != NULL) {
        ListNode* new_head = stk->head->next;
        free(stk->head->data);
        free(stk->head);
        stk->head = new_head;
        stk->len--;
    }
}

void stack_top_coord(Stack* stk, Coord* coord) {
    if (stk->head != NULL) {
        Coord* t_coord = (Coord*)(stk->head->data);
        coord->x = t_coord->x;
        coord->y = t_coord->y;
    }
}

void make_stack(Stack** _stk) {
    Stack* stk = (Stack*)malloc(sizeof(Stack));
    stk->head = NULL;
    stk->len = 0;
    stk->push_coord = stack_push_coord;
    stk->pop_coord = stack_pop_coord;
    stk->top_coord = stack_top_coord;

    /* write back */
    *_stk = stk;
}

void free_stack(Stack* stk) {
    ListNode* cur = stk->head;
    ListNode* temp;
    size_t i;
    for (i = 0; i < stk->len; i++) {
        temp = cur->next;
        free(cur->data);
        free(cur);
        cur = temp;
    }
    free(stk);
    stk = NULL;
}

void make_8coord_offset(CoordOffset** _offset) {
    CoordOffset* offset = (CoordOffset*)malloc(sizeof(CoordOffset));
    offset->num = 8;
    offset->x = (int*)malloc(sizeof(int)*offset->num);
    offset->y = (int*)malloc(sizeof(int)*offset->num);

    offset->x[0] = -1; offset->y[0] = -1;
    offset->x[1] = -1; offset->y[1] =  0;
    offset->x[2] = -1; offset->y[2] =  1;
    offset->x[3] =  0; offset->y[3] = -1;
    offset->x[4] =  0; offset->y[4] =  1;
    offset->x[5] =  1; offset->y[5] = -1;
    offset->x[6] =  1; offset->y[6] =  0;
    offset->x[7] =  1; offset->y[7] =  1;

    /* write back */
    *_offset = offset;
}

void free_coord_offset(CoordOffset* offset) {
    if (offset) {
        if (offset->x) {
            free(offset->x);
            offset->x = NULL;
        }
        if (offset->y) {
            free(offset->y);
            offset->y = NULL;
        }
        free(offset);
        offset = NULL;
    }
}

/* #define DEBUG */
int main() {
#ifdef DEBUG
    const char* input_txt_pth = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
    freopen(input_txt_pth, "r", stdin);
#endif

    int m, n, i, j;
    size_t k;

    #define maxn 105
    unsigned char data[maxn][maxn];
    int vis[maxn][maxn];

    /* here we use 8 neighbours */
    CoordOffset* offset = NULL;
    make_8coord_offset(&offset);

    while (scanf("%d %d", &m, &n) && m &&n) {
        int count = 0; /* 连通块 */
        memset(vis, 0, sizeof(vis));
        for (i = 0; i < m; i++) {
            scanf("%s", data[i]);
        }

        /* std::stack<Coord> stk; */
        Stack* stk;
        make_stack(&stk);

        Coord cd;

        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                cd.x = i; cd.y = j;
                if (vis[cd.x][cd.y] > 0 || data[cd.x][cd.y] != '@') continue;
                count++;

                /* stk.push(cd); */
                stack_push_coord(stk, &cd);
                /* while (!stk.empty()) { */
                while(stk->len!=0) {
                    /* cd = stk.top(); */
                    /* stack_top_coord(stk, &cd); */
                    stk->top_coord(stk, &cd);
                    /* stk.pop(); */
                    /* stack_pop_coord(stk); */
                    stk->pop_coord(stk);

                    vis[cd.x][cd.y] = count;

                    Coord tmp;
                    for (k = 0; k < offset->num; k++) {
                        tmp.x = cd.x + offset->x[k];
                        tmp.y = cd.y + offset->y[k];
                        if (tmp.x < 0 || tmp.x >= m || tmp.y < 0 || tmp.y >= n) continue;
                        if (vis[tmp.x][tmp.y] > 0 || data[tmp.x][tmp.y] != '@') continue;
                        /* stk.push(tmp); */
                        /* stack_push_coord(stk, &tmp); */
                        stk->push_coord(stk, &tmp);
                    }
                }
            }
        }
        free_stack(stk);

        printf("%d\n", count);

#ifdef DEBUG
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                printf("%3d", vis[i][j]);
            }
            printf("\n");
        }
        printf("\n");
#endif
    }

    free_coord_offset(offset);
    return 0;
}

4.DFS+并查集实现

#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int fa[10500];
int m, n, cnt, vis[105][105];
char mp[105][105];
int find(int x) {
    if (fa[x] == x) return x;
    fa[x] = find(fa[x]);
    return fa[x];
}

void merge(int x, int y) {
    int fx = find(x);
    int fy = find(y);
    if (fx == fy) return;
    fa[fx] = fy;
}


void dfs(int x, int y, int fx, int fy) {
    if (x < 0 || x >= m || y < 0 || y >= n) return;
    if (vis[x][y] || mp[x][y] == '*') return;
    vis[x][y] = 1;
    /* cout<<"x || y || fx || fy : "<<x<<" || "<<y<<" || "<<fx<<" || "<<fy<<endl; */
    if (fx != -1) {
        merge(x*m + y, fx*m + fy);
    }
    int i, j;
    for (i = -1; i < 2; i++) {
        for (j = -1; j < 2; j++) {
            if (!i && !j) continue;
            dfs(x + i, y + j, x, y);
        }
    }
}

/* #define LOCAL */
int main() {
#ifdef LOCAL
    const char* input_txt = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
    freopen(input_txt, "r", stdin);
#endif
    int i, j;
    while (scanf("%d%d", &m, &n) == 2 && m && n) {
        cnt = 0;
        memset(vis, 0, sizeof(vis));
        for (i = 0; i < m; i++) {
            scanf("%s", mp[i]);
        }
        for (i = 0; i < 10500; i++) {
            fa[i] = i;
        }
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                if (!vis[i][j] && mp[i][j] == '@') {
                    dfs(i, j, -1, -1);
                    cnt++;
                }
            }
        }
        printf("%d\n", cnt);

#ifdef LOCAL
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                printf("%3d", vis[i][j]);
            }
            printf("\n");
        }
        printf("\n");
#endif

    }
    return 0;
}

5.DFS+并查集+不使用全局变量+简单封装为结构体
修改自 UVA572 (并查集解法) 。这种写法有点问题：已经用了dfs，dfs里用并查集多此一举，如果用并查集就不应该递归调用dfs。

#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct FSU_Node {
    int p;    /* parent id */
    int rank;
    int vis; /* group(connected component) id */
} FSU_Node;

/*
get node's root id
@param x: node id
@param nodes: all nodes in map
*/
int fus_find(int x, FSU_Node* nodes) {
    if (nodes[x].p == x) return x;

    nodes[x].p = fus_find(nodes[x].p, nodes);
    return nodes[x].p;
}

/*
merge two node groups
@param a: a node from one node group
@param b: a node from another node group
*/
void fus_union(int a, int b, FSU_Node* nodes)
{
    int ra = fus_find(a, nodes); /* ra: root id of a */
    int rb = fus_find(b, nodes); /* rb: root id of b */
    if (ra == rb) {
        return;
    }

    if (nodes[ra].rank > nodes[rb].rank)
    {
        nodes[rb].p = ra;
    }
    else {
        if (nodes[ra].rank == nodes[rb].rank)
        {
            nodes[rb].rank++;
        }
        nodes[ra].p = rb;
    }
}

typedef struct ImageSize {
    int w, h;
} ImageSize;

typedef struct Coord {
    int row, col;
} Coord;

void fus_dfs(const Coord* pt, const Coord* f_pt, FSU_Node* nodes, ImageSize* sz, unsigned char* mp) {
    int row = pt->row;
    int col = pt->col;

    int f_row = f_pt->row;
    int f_col = f_pt->col;

    if (row < 0 || row >= sz->h || col < 0 || col >= sz->w) return;

    int id = row * sz->w + col;
    int fid = f_row * sz->w + f_col;

    /* if (vis[id] || mp[id] == '*') return; */
    if (nodes[id].vis || mp[id] == '*') return;
    /* vis[id] = 1; */
    nodes[id].vis = 1;

    if (f_row != -1) {
        fus_union(id, fid, nodes);
    }

    int i, j;
    Coord neighbor;
    for (i = -1; i < 2; i++) {
        for (j = -1; j < 2; j++) {
            if (!i && !j) continue;
            neighbor.row = row + i;
            neighbor.col = col + j;
            fus_dfs(&neighbor, pt, nodes, sz, mp);
        }
    }
}

/*#define LOCAL*/
int main() {
#ifdef LOCAL
    const char* input_txt = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
    freopen(input_txt, "r", stdin);
#endif

#define MAXN 105
    int m, n, cnt, i, j;

    /* int vis[MAXN*MAXN]; */
    unsigned char mp[MAXN*MAXN];
    FSU_Node nodes[MAXN*MAXN];

    int idx;

    while (scanf("%d%d", &m, &n) == 2 && m && n) {
        cnt = 0;
        /* memset(vis, 0, sizeof(int)*MAXN*MAXN); */
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                idx = i * n + j;
                scanf(" %c", &mp[idx]);
                /* printf("! %c !", mp[idx]); */
            }
        }
        for (i = 0; i < m*n; i++) {
            nodes[i].p = idx;
            nodes[i].rank = 1;
            nodes[i].vis = 0;
        }

        ImageSize im_sz;
        im_sz.h = m;
        im_sz.w = n;
        Coord pt;
        Coord f_pt;
        f_pt.row = -1;
        f_pt.col = -1;

        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                idx = i * n + j;
                /* if (!vis[idx] && mp[idx] == '@') { */
                if (!nodes[idx].vis && mp[idx] == '@') {
                    /* dfs(i, j, -1, -1); */
                    pt.row = i;
                    pt.col = j;
                    /* fus_dfs(&pt, &f_pt, nodes, &im_sz, vis, mp); */
                    fus_dfs(&pt, &f_pt, nodes, &im_sz, mp);
                    cnt++;
                }
            }
        }
        printf("%d\n", cnt);

#ifdef LOCAL
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                idx = i * m + j;
                /* printf("%3d", vis[idx]); */
                printf("%c", mp[idx]);
            }
            printf("\n");
        }
        printf("\n");
#endif
    }

    return 0;
}

这里的教训是，如果在双重for循环中使用变量x、y来表示坐标，容易把2维度坐标->1维坐标的计算算错。使用row,col能减少犯错可能；
另外就是数据读取，这里改成%c，则需要过滤掉换行符\n，方法是scanf时的格式串首部添加空格：scanf(" %c", &xx)

6. 并查集，去掉了DFS
思路：遍历每个像素点，每个像素点用并查集算法合并周边8邻域中为'@'的像素点。再次遍历，统计每个'@'像素对应的等价类（root节点）的值。第三次遍历，把第二次统计的值当中cnt数大于0的累计，就是区域个数。在统计连通域个数的时候顺带把每个连通域id（像素的parent值）修改为从1开始严格单调增的序列，开启LOCAL和LOCAL_DEBUG宏可以看到。

和通常用的模板写法略有差别，比如返回root的递归终止条件，比如root初值。

不得不说，uDebug是个好东西。

#include <stdio.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct FSU_Node {
    int p;    /* parent id */
    int rank;
} FSU_Node;


/*
get node's root id
@param x: node id
@param nodes: all nodes in map
*/

int fus_find(int x, FSU_Node* nodes) {
    if (nodes[x].p == x) {
        return x;
    }

    nodes[x].p = fus_find(nodes[x].p, nodes);
    return nodes[x].p;
}

/*
merge two node groups
@param a: a node from one node group
@param b: a node from another node group
*/
void fus_union(int a, int b, FSU_Node* nodes)
{
    int ra = fus_find(a, nodes); /* ra: root id of a */
    int rb = fus_find(b, nodes); /* rb: root id of b */
    if (ra == rb) {
        return;
    }

    if (nodes[ra].rank > nodes[rb].rank) {
        nodes[rb].p = ra;
    }
    else {
        if (nodes[ra].rank == nodes[rb].rank) {
            nodes[rb].rank++;
        }
        nodes[ra].p = rb;
    }
}

/* #define LOCAL */
/* #define LOCAL_DEBUG */
int main() {
#ifdef LOCAL
    const char* input_txt = "F:/zhangzhuo/debug/OJ/UVA-572.txt";
    freopen(input_txt, "r", stdin);
#endif

#define MAXN 105
    int m, n, cnt, i, j, k;

    int shift_x[8] = { -1, -1, -1,  0, 0,  1, 1, 1 };
    int shift_y[8] = { -1,  0,  1, -1, 1, -1, 0, 1 };

    unsigned char mp[MAXN*MAXN];
    FSU_Node nodes[MAXN*MAXN];

    int idx;

    while (scanf("%d%d", &m, &n) == 2 && m && n) {
        cnt = 0;
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                idx = i * n + j;
                scanf(" %c", &mp[idx]);
            }
        }
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                idx = i * n + j;
                nodes[idx].p = idx;
                nodes[idx].rank = 1;
            }
        }


        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                idx = i * n + j;
                if (mp[idx] != '@') continue;
                for (k = 0; k < 8; k++) {
                    int row = i + shift_x[k];
                    int col = j + shift_y[k];
                    int neighbor_idx = row * n + col;
                    if (row < 0 || row >= m || col < 0 || col >= n || mp[neighbor_idx] != '@') continue;
                    fus_union(idx, neighbor_idx, nodes);
                }
            }
        }

        int bowl[MAXN*MAXN] = { 0 };
        int label_cnt = 0;
        for (i = 0; i < m*n; i++) {
            if (mp[i] != '@') continue;
            int t = fus_find(i, nodes);
            nodes[i].p = t;
            if (bowl[t] == 0) {
                label_cnt++;
                bowl[t] = label_cnt;
            }   
        }
        printf("%d\n", label_cnt);

#ifdef LOCAL_DEBUG
        /* print out debug info */
        for (i = 0; i < m; i++) {
            for (j = 0; j < n; j++) {
                idx = i * n + j ;
                if (mp[idx] == '@') {
                    /* printf("%3d", fus_find(idx, nodes)); */
                    /* printf("%3d", nodes[idx].p); */
                    printf("%3d", bowl[nodes[idx].p]);
                }
                else {
                    printf("%3c", '*');
                }
            }
            printf("\n");
        }
        printf("\n");
#endif

    }

    return 0;
}

转载于:https://www.cnblogs.com/zjutzz/p/11017619.html

weixin_30493401
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
formation of gold deposits.pdf
05-03
formation of gold deposits.pdf，形成与成因，分布与产状
Uva 572 Oil Deposits
weixin_30813225的博客
06-01 43
思路：可以用DFS求解。遍历这个二维数组，没发现一次未被发现的‘@’，便将其作为起点进行搜索。最后的答案，是这个遍历过程中发现了几次为被发现的‘@’ import java.util.*; public class Main{ public static void main(String[] args) { Scanner in = new S...
HDU1241 POJ1562 UVa572 UVALive5317 Oil Deposits【DFS】
海岛Blog
07-14 1599
  Oil Deposits Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 17768   Accepted: 9440   Description The GeoSurvComp geologic survey company is responsible for detectin...
DFS入门精讲：油田（Oil Deposits UVA572）
qq_38121348的博客
05-23 964
传送门：https://vjudge.net/problem/UVA-572 具体原题看链接。 大意：输入一个m行n列字符矩阵，统计字符@组成多少个八连块（如果两个字符@所在格子横竖对角线方向相邻就是八连块）。 简单的DFS遍历，适合入门，我把代码能打的注释尽量都打了 #include #include const int maxn=100+5; char pic[maxn][maxn
油田(Oil Deposits)
梦空间
02-24 1804
Oil Deposits Time Limit:3000MS   Memory Limit:Unknown   64bit IO Format:%lld & %llu Submit  Status Description The GeoSurvComp geologic survey company is responsible for
eth2deposits-subgraph-onyx
02-16
--data '{"query": "{deposits(where:{validatorPubKey:\"0xa2fbaa9e4b454c672ff1e89cd70c5f5e84d7dfab9a3b011c12d56d6f3e56aef0a760ba3e7df78ed8f2783971ea54962a\"}){index amount withdrawalCredentials ...
Laravel开发-deposits
08-28
Laravel开发-deposits Laravel存款
Total Checkable Deposits支票存款总额-数据集
03-09
这是由美联储经济数据库（FRED）托管的美联储数据集。FRED有一个数据平台，它们根据数据更新的频率来更新其信息。 TCD.csv TCDSL.csv total-checkable-deposits_...total-checkable-deposits_metadata_1.json
Small Time Deposits – Total 少量定期存款-总计-数据集
03-28
这是由美联储经济数据库（FRED）托管的美联储数据集。M2的小面额定期存款部分包括银行定期存款和余额不到100,000美元的储蓄帐户。M2的小面额定期存款部分不包括个人退休账户（IRA）和Keogh存款机构的余额，因为退休...
C语言简要（四）
m0_74057302的博客
05-21 301
有没有好心师傅教教孩子逆向和pwn啊°꒰๑'ꀾ'๑꒱°
std::thread线程生命周期与线程对象生命周期的联系
zhaominyong的专栏
05-17 325
std::thread线程生命周期与线程对象生命周期的联系
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 754
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
堆与堆排序算法实现分享
Mrluo386的博客
05-22 246
在计算机科学中，堆是一种特殊的完全二叉树数据结构，常被用于实现优先队列等应用场景。本文将通过一个C语言示例，详细介绍如何实现一个基于数组的大顶堆及其基本操作——包括堆的创建、插入元素（入堆）、删除最大元素（出堆）以及利用这些操作实现堆排序算法。本代码实例主要涉及到了一个Heap结构体的定义、堆的创建、元素的插入与删除，以及堆排序的整个过程。
pyqt5 子线程如何操作主线程GUI
qq_64919823的博客
05-17 978
在使用pyqt5编写gui时遇到两个问题，会导致界面崩溃，今天就围绕这两个问题来简单说明和改进。1.在主线程中使用while无限循环会导致界面崩溃2.在子线程中操作主线程gui会导致界面崩溃。
LLVM入门教学——SanitizerCoverage插桩
计算机硕士的博客
05-18 798
LLVM入门教学——SanitizerCoverage插桩，计算代码覆盖率。
Python教程：使用Python和PyQt编写进制转换器工具
最新发布
复现的博客
05-23 312
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环）
<font color="Pink">Tisfy的博客</font>
05-18 878
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环） 给你两个下标从 0 开始的整数数组 nums 和 divisors 。 divisors[i] 的 可整除性得分 等于满足 nums[j] 能被 divisors[i] 整除的下标 j 的数量。 返回 可整除性得分 最大的整数 divisors[i] 。如果有多个整数具有最大得分，则返回数值最小的一个。
C语言基础：数组在内存存储的大小（sizeof,strlen求大小）
weixin_64484421的博客
05-20 113
会报错， &arr-数组的地址，按理说存在数组指针里面 char(*p)[7]=&arr;元素类型为char(*)[7];而strlen接收的类型是 const char *，有所冲突。16 第二行的数组名，计算的是第二行的数组大小（错误）strlen 求字符串长度的函数，遇到\0结束。
salt deposits在遥感领域的中文意思
06-04
在遥感领域中，salt deposits通常被翻译为盐矿床。盐矿床是指地下含有丰富盐矿资源的地质构造单元，通常是由古代海洋沉积物演化而成，是一种重要的非金属矿产资源。在遥感数据中，盐矿床通常表现为一片具有特殊光谱...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值