HDU 2518 Dominoes

最新推荐文章于 2013-03-06 22:16:00 发布
最新推荐文章于 2013-03-06 22:16:00 发布
阅读量99 收藏
点赞数

HDU_2518

    这个题目明显就是裸的Dancing Links，只不过由于情况实在太多了，写起来超级繁琐，而且写完之后几乎不可能在规定时间内出解（大家交的都是0ms的，估计都是打表交的），于是就只好把6种情况的结果存到数组里直接输出了。

View Code // 打表程序 
#include<stdio.h>
#include<string.h>
#define MAXN 5810
#define MAXM 80
#define MAXD 35510
#define HASH 100007
#define SIZE 100010
#define INF 0x3f3f3f3f
typedef long long LL;
int dx[8][12][4] =
{
    {// 0
        {1, 2, 2, 2}, // 1
        {0, 0, 0, 0}, // 2
        {1, 1, 1, 2}, // 3
        {0, 1, 1, 1}, // 4
        {1, 1, 1, 1}, // 5
        {1, 1, 2, 2}, // 6
        {1, 1, 1, 1}, // 7
        {1, 1, 1, 2}, // 8
        {1, 1, 2, 2}, // 9
        {1, 2, 2, 2}, // 10
        {0, 1, 1, 1}, // 11
        {0, 0, 1, 1}, // 12
    },
    {// 1
        {1, 2, 2, 2}, // 1
        {1, 2, 3, 4}, // 2
        {1, 1, 1, 2}, // 3
        {0, 1, 2, 2}, // 4
        {1, 2, 3, 3}, // 5
        {1, 1, 2, 2}, // 6
        {1, 2, 2, 3}, // 7
        {0, 1, 2, 2}, // 8
        {1, 1, 1, 2}, // 9
        {1, 1, 1, 2}, // 10
        {0, 1, 1, 2}, // 11
        {1, 2, 2, 3}, // 12
    },
    {// 2
        {0, 0, 1, 2}, // 1
        {0, 0, 0, 0}, // 2
        {1, 1, 1, 2}, // 3
        {0, 0, 1, 1}, // 4
        {0, 0, 0, 1}, // 5
        {0, 1, 1, 2}, // 6
        {0, 0, 0, 1}, // 7
        {1, 1, 1, 2}, // 8
        {0, 1, 1, 2}, // 9
        {0, 0, 1, 2}, // 10
        {0, 0, 1, 1}, // 11
        {0, 1, 1, 1}, // 12
    },
    {// 3
        {0, 0, 1, 2}, // 1
        {1, 2, 3, 4}, // 2
        {1, 1, 1, 2}, // 3
        {0, 1, 2, 2}, // 4
        {0, 1, 2, 3}, // 5
        {0, 1, 1, 2}, // 6
        {1, 1, 2, 3}, // 7
        {0, 1, 2, 2}, // 8
        {1, 1, 1, 2}, // 9
        {1, 1, 1, 2}, // 10
        {1, 1, 2, 2}, // 11
        {1, 1, 2, 3}, // 12
    },
    {// 4
        {1, 2, 2, 2}, // 1
        {0, 0, 0, 0}, // 2
        {1, 1, 1, 2}, // 3
        {0, 1, 1, 1}, // 4
        {1, 1, 1, 1}, // 5
        {1, 1, 2, 2}, // 6
        {1, 1, 1, 1}, // 7
        {1, 1, 1, 2}, // 8
        {1, 1, 2, 2}, // 9
        {1, 2, 2, 2}, // 10
        {0, 1, 1, 1}, // 11
        {0, 0, 1, 1}, // 12
    },
    {// 5
        {0, 0, 1, 2}, // 1
        {1, 2, 3, 4}, // 2
        {1, 1, 1, 2}, // 3
        {0, 1, 2, 2}, // 4
        {0, 1, 2, 3}, // 5
        {0, 1, 1, 2}, // 6
        {1, 1, 2, 3}, // 7
        {0, 1, 2, 2}, // 8
        {1, 1, 1, 2}, // 9
        {1, 1, 1, 2}, // 10
        {1, 1, 2, 2}, // 11
        {1, 1, 2, 3}, // 12
    },
    {// 6
        {0, 0, 1, 2}, // 1
        {0, 0, 0, 0}, // 2
        {1, 1, 1, 2}, // 3
        {0, 0, 1, 1}, // 4
        {0, 0, 0, 1}, // 5
        {0, 1, 1, 2}, // 6
        {0, 0, 0, 1}, // 7
        {1, 1, 1, 2}, // 8
        {0, 1, 1, 2}, // 9
        {0, 0, 1, 2}, // 10
        {0, 0, 1, 1}, // 11
        {0, 1, 1, 1}, // 12
    },
    {// 7
        {1, 2, 2, 2}, // 1
        {1, 2, 3, 4}, // 2
        {1, 1, 1, 2}, // 3
        {0, 1, 2, 2}, // 4
        {1, 2, 3, 3}, // 5
        {1, 1, 2, 2}, // 6
        {1, 2, 2, 3}, // 7
        {0, 1, 2, 2}, // 8
        {1, 1, 1, 2}, // 9
        {1, 1, 1, 2}, // 10
        {0, 1, 1, 2}, // 11
        {1, 2, 2, 3}, // 12
    },
};
int dy[8][12][4] =
{
    {// 0
        {0, 0, 1, 2}, // 1
        {1, 2, 3, 4}, // 2
        {-1, 0, 1, 0}, // 3
        {2, 0, 1, 2}, // 4
        {0, 1, 2, 3}, // 5
        {0, 1, 1, 2}, // 6
        {-1, 0, 1, 2}, // 7
        {-2, -1, 0, -2}, // 8
        {0, 1, -1, 0}, // 9
        {0, -1, 0, 1}, // 10
        {1, -1, 0, 1}, // 11
        {1, 2, -1, 0}, // 12
    },
    {// 1
        {0, -2, -1, 0}, // 1
        {0, 0, 0, 0}, // 2
        {-1, 0, 1, 0}, // 3
        {1, 1, 0, 1}, // 4
        {0, 0, 0, -1}, // 5
        {-1, 0, -2, -1}, // 6
        {0, -1, 0, 0}, // 7
        {1, 1, 1, 2}, // 8
        {-1, 0, 1, 1}, // 9
        {-2, -1, 0, 0}, // 10
        {1, 0, 1, 1}, // 11
        {0, 0, 1, 1}, // 12
    },
    {// 2
        {1, 2, 2, 2}, // 1
        {1, 2, 3, 4}, // 2
        {-1, 0, 1, 0}, // 3
        {1, 2, 0, 2}, // 4
        {1, 2, 3, 3}, // 5
        {1, 1, 2, 2}, // 6
        {1, 2, 3, 2}, // 7
        {-2, -1, 0, -2}, // 8
        {1, -1, 0, 0}, // 9
        {1, 2, 1, 1}, // 10
        {1, 2, 0, 1}, // 11
        {1, -2, -1, 0}, // 12
    },
    {// 3
        {1, 2, 0, 0}, // 1
        {0, 0, 0, 0}, // 2
        {-1, 0, 1, 0}, // 3
        {1, 0, 0, 1}, // 4
        {1, 0, 0, 0}, // 5
        {1, -1, 0, -1}, // 6
        {0, 1, 0, 0}, // 7
        {1, 1, 1, 2}, // 8
        {0, 1, 2, 1}, // 9
        {0, 1, 2, 0}, // 10
        {0, 1, 0, 1}, // 11
        {0, 1, 1, 1}, // 12
    },
    {// 4
        {0, -2, -1, 0}, // 1
        {1, 2, 3, 4}, // 2
        {-1, 0, 1, 0}, // 3
        {2, 0, 1, 2}, // 4
        {-3, -2, -1, 0}, // 5
        {-1, 0, -2, -1}, // 6
        {-2, -1, 0, 1}, // 7
        {0, 1, 2, 2}, // 8
        {-1, 0, 0, 1}, // 9
        {0, -1, 0, 1}, // 10
        {1, 0, 1, 2}, // 11
        {1, 2, 2, 3}, // 12
    },
    {// 5
        {1, 2, 2, 2}, // 1
        {0, 0, 0, 0}, // 2
        {-1, 0, 1, 0}, // 3
        {1, 1, 0, 1}, // 4
        {1, 1, 1, 1}, // 5
        {1, 1, 2, 2}, // 6
        {-1, 0, 0, 0}, // 7
        {-1, -1, -2, -1}, // 8
        {-2, -1, 0, -1}, // 9
        {-2, -1, 0, 0}, // 10
        {-1, 0, -1, 0}, // 11
        {-1, 0, -1, -1}, // 12
    },
    {// 6
        {1, 2, 0, 0}, // 1
        {1, 2, 3, 4}, // 2
        {-1, 0, 1, 0}, // 3
        {1, 2, 0, 2}, // 4
        {1, 2, 3, 0}, // 5
        {1, -1, 0, -1}, // 6
        {1, 2, 3, 1}, // 7
        {0, 1, 2, 2}, // 8
        {1, 1, 2, 1}, // 9
        {1, 2, 1, 1}, // 10
        {1, 2, 1, 2}, // 11
        {1, 1, 2, 3}, // 12
    },
    {// 7
        {0, 0, 1, 2}, // 1
        {0, 0, 0, 0}, // 2
        {-1, 0, 1, 0}, // 3
        {1, 0, 0, 1}, // 4
        {0, 0, 0, 1}, // 5
        {0, 1, 1, 2}, // 6
        {0, 0, 1, 0}, // 7
        {1, 0, -1, 0}, // 8
        {-1, 0, 1, -1}, // 9
        {0, 1, 2, 0}, // 10
        {1, 0, 1, 0}, // 11
        {0, -1, 0, -1}, // 12
    },
};
struct HashMap
{
    int head[HASH], size, next[SIZE];
    LL st[SIZE];
    void init()
    {
        memset(head, -1, sizeof(head)), size = 0;
    }
    int find(LL _st)
    {
        int i, h = (_st & 0x7fffffff) % HASH;
        for(i = head[h]; i != -1; i = next[i])
            if(_st == st[i]) break;
        return i;
    }
    void push(LL _st)
    {
        int i, h = (_st & 0x7fffffff) % HASH;
        st[size] = _st;
        next[size] = head[h], head[h] = size ++;
    }
}hm;
struct Info
{
    int d, id, x, y;
}info[MAXD];
int N, M, size, U[MAXD], D[MAXD], L[MAXD], R[MAXD], C[MAXD], Q[MAXN], ANS;
int S[MAXM], H[MAXN], g[MAXM][MAXM], t[MAXM][MAXM];
LL fac[MAXM], f[MAXM];
inline int inside(int x, int y)
{
    return x >= 1 && x <= N && y >= 1 && y <= M;
}
void prep(int m)
{
    int i;
    for(i = 0; i <= m; i ++)
    {
        U[i] = D[i] = i;
        L[i + 1] = i, R[i] = i + 1;
        S[i] = 0;
    }
    R[m] = 0, size = m;
    memset(H, -1, sizeof(H));
}
void insert(int r, int c, int d, int id, int x, int y)
{
    ++ size;
    C[size] = c, ++ S[c];
    D[size] = D[c], U[size] = c;
    U[D[c]] = size, D[c] = size;
    if(H[r] == -1) H[r] = L[size] = R[size] = size;
    else
    {
        R[size] = R[H[r]], L[size] = H[r];
        L[R[H[r]]] = size, R[H[r]] = size;
    }
    info[size].d = d, info[size].id = id, info[size].x = x, info[size].y = y;
}
inline int place(int d, int id, int x, int y)
{
    int i;
    for(i = 0; i < 4; i ++)
        if(!inside(x + dx[d][id][i], y + dy[d][id][i])) return 0;
    return 1;
}
int appear(int d, int id, int x, int y)
{
    int i;
    LL ans = (x - 1) * M + y;
    for(i = 0; i < 4; i ++) ans += f[i + 1] * ((x + dx[d][id][i] - 1) * M + y + dy[d][id][i]);
    if(hm.find(ans) != -1) return 1;
    hm.push(ans);
    return 0;
}
void init()
{
    int i, j, k, d, id, r = 0, c;
    prep(N * M + 12);
    hm.init();
    for(d = 0; d < 8; d ++)
        for(id = 0; id < 12; id ++)
            for(i = 1; i <= N; i ++)
                for(j = 1; j <= M; j ++)
                    if(place(d, id, i, j) && !appear(d, id, i, j))
                    {
                        ++ r;
                        insert(r, id + 1, d, id, i, j), insert(r, (i - 1) * M + j + 12, d, id, i, j);
                        for(k = 0; k < 4; k ++)
                        {
                            c = (i + dx[d][id][k] - 1) * M + j + dy[d][id][k] + 12;
                            insert(r, c, d, id, i, j);
                        }
                    }
}
void remove(int c)
{
    int i, j;
    R[L[c]] = R[c], L[R[c]] = L[c];
    for(i = D[c]; i != c; i = D[i])
        for(j = R[i]; j != i; j = R[j])
            U[D[j]] = U[j], D[U[j]] = D[j], -- S[C[j]];
}
void resume(int c)
{
    int i, j;
    for(i = U[c]; i != c; i = U[i])
        for(j = L[i]; j != i; j = L[j])
            U[D[j]] = j, D[U[j]] = j, ++ S[C[j]];
    R[L[c]] = c, L[R[c]] = c;
}
LL encode(int g[][MAXM])
{
    int i, j, k = 0;
    LL ans = 0;
    for(i = 1; i <= N; i ++)
        for(j = 1; j <= M; j ++)
            ans += fac[k ++] * g[i][j];
    return ans;
}
void deal(int dep)
{
    int i, j, k, d, id, x, y, flag = 0;
    LL ans;
    for(k = 0; k < dep; k ++)
    {
        j = Q[k];
        d = info[j].d, id = info[j].id, x = info[j].x, y = info[j].y;
        g[x][y] = id;
        for(i = 0; i < 4; i ++) g[x + dx[d][id][i]][y + dy[d][id][i]] = id;
    }
    ans = encode(g);
    if(hm.find(ans) != -1) return;
    for(i = 1, x = N; i <= N; i ++, x --)
        for(j = 1, y = M; j <= M; j ++, y --) t[x][y] = g[i][j];
    ans = encode(t);
    if(hm.find(ans) != -1) return;
    for(i = 1; i <= N; i ++)
        for(j = 1, y = M; j <= M; j ++, y --) t[i][y] = g[i][j];
    ans = encode(t);
    if(hm.find(ans) != -1) return;
    for(i = 1, x = N; i <= N; i ++, x --)
        for(j = 1, y = M; j <= M; j ++, y --) g[x][y] = t[i][j];
    ans = encode(g);
    if(hm.find(ans) != -1) return;
    ++ ANS, hm.push(encode(g));
}
void dance(int dep)
{
    if(R[0] == 0)
    {
        deal(dep);
        return ;
    }
    int i, j, t = INF, id;
    for(i = R[0]; i != 0; i = R[i])
        if(S[i] < t) t = S[i], id = i;
    remove(id);
    for(i = D[id]; i != id; i = D[i])
    {
        for(j = R[i]; j != i; j = R[j]) remove(C[j]);
        Q[dep] = i, dance(dep + 1);
        for(j = L[i]; j != i; j = L[j]) resume(C[j]);
    }
    resume(id);
}
void solve()
{
    ANS = 0;
    hm.init();
    dance(0);
    printf("%d\n", ANS);
}
int main()
{
    freopen("cin.in", "r", stdin);
    freopen("cout.out", "w", stdout);
    fac[0] = f[0] = 1;
    for(int i = 1; i <= 60; i ++) fac[i] = fac[i - 1] * 19, f[i] = f[i - 1] * 61;
    while(scanf("%d%d", &N, &M) == 2)
    {
        init();
        solve();
    }
    return 0;
}

 

View Code // AC程序 
#include<stdio.h>
#include<string.h>
#include<algorithm>
int a[] = {0, 0, 0, 2, 368, 1010, 2339};
int main()
{
    int x, y;
    while(scanf("%d%d", &x, &y) == 2)
    {
        if(x > y) std::swap(x, y);
        printf("%d\n", a[x]);    
    }
    return 0;
}

 

weixin_33755649
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[DLX精确覆盖+打表] hdu 2518 Dominoes
weixin_33701617的博客
06-16 75
题意： 就是给12种图形，旋转，翻折。有多少种方法构成n*m=60的矩形 思路： 裸的精确覆盖。就是建图麻烦 个人太挫，直接手写每一个图形的各种形态 须要注意的是最后的答案须要除以4 代码： #include"stdio.h" #include"algorithm" #include"string.h" #include"iostream" #include"queue" #...
hdu 2518 Dominoes
Dwylkz
09-05 764
/* What a TROUBLESOME Problem!!! Obviously, we should construct a sparse table which has 60 * 63 rows and 60 + 12 colums. 60 * 63 rows 60 means we can place the "center" of a block on a spec
hdu 2518（dfs）Another Eight Puzzle
weixin_30596165的博客
03-06 78
思路：dfs的思想，比较简单的搜索题。 代码实现： #include<iostream> #include<cstring> using namespace std; int a[10],b[10],flag,visited[10]; int yanzheng(int i) { if(i==1)//和A相连的字母，下同 { ...
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
Rightmost Digit_hdu_
10-03
【标题】"Rightmost Digit HDU" 这道题目来源于HDU（杭州电子科技大学）的在线判题系统，通常这类题目是编程竞赛或者算法训练的一部分。"Rightmost Digit"直译为“最右边的数字”，我们可以推测这是一个关于数字...
hdu1020.rar_hdu1020
09-20
HDU 1020，又被称为"猜数字"，是一个经典的在线算法竞赛题目，源自中国杭州电子科技大学（Hangzhou Dianzi University）的在线评测系统HDU ACM/ICPC。这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，...
全国计算机三级（网络技术）做题技巧
07-22
全国计算机三级（网络技术）做题技巧
记录 cocos 开发问题 ，微信 wx.xxx函数 报找不到名称“wx”
07-22
wx api 文件
20231108-173536 时间箭贴板
07-22
时间粘贴小工具 启动后点击回车 可以得到时间字符串 直接粘贴可用
毕业设计javajsp西饼点心店收费系统(ssh)-qrp源码含文档工具包
07-22
毕业设计javajsp西饼点心店收费系统(ssh)-qrp源码含文档工具包 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 点心店管理系统是针对点心店内部而设计的，应用于点心店的局域网，这样可以使得点心店内部管理更有效的联系起来。系统的主要功能包括：供货商信息管理、点心信息管理、采购申请管理与物品采购管理。 包含：源码、数据库脚本、论文、开题报告、环境工具包、相同框架项目的安装教程（在说明文档中）
275、基于stm32的电压可调、电流智能检测系统设计（原理图、PCB图、源代码）
最新发布
07-22
275、基于stm32的电压可调、电流智能检测系统设计（原理图、PCB图、源代码） 功能：系统使用stm32单片机设计，USB 5V供电，实现3.3V——12V可调输出，电流测量范围1uA——500mA，液晶LCD12864显示，通过串口上传信息和串口修改输出电压；各功能如下： 1、使用stm32为核心，keil编程； 2、输出3.3V-12V可调电压； 3、输出电流显示在LCD12864上，输出电流检测范围是1uA——500mA； 4、串口同步上传电压和电流信息； 5、支持串口指令修改输出电压值；
C++《使用NeuroSky和摄像头实现的简易脑波控制的图片拍摄并且识别单词或图片中的植物》+源代码+文档说明
07-22
<项目介绍> - 使用NeuroSky和摄像头实现的简易脑波控制的图片拍摄并且识别单词或图片中的植物 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 --------
ABB字迹书写技术文档
07-22
内容概要：包含指导使用ABB机器人完成“毅”字在写字板上书写的技术文档。在执行过程中将提供更多可能错误、其他路径，并引导读者在此基础上完成微量调整。会介绍部分原理，使读者在学习后增进对ABB仿真功能的了解，例如：RAPID的使用、仿真中碰撞监控的设置等 适合人群：适合ABB RobotStudio6.18.01仿真软件初学者 应用场景：应用于汇博机器人教学工作台，可以引导未接触过相关领域的人群实现仿真软件的编写直至最终烧录 能学到什么：①ABB RobotStudio6.18.01使用技巧；②ABB机器人运行过程；3、烧录方法；4、ABB机器人运行的弊端 阅读建议：此资源以开发ABB RobotStudio6.18.01RAPID程序学习其原理和内核，不仅是代码编写实现也更注重内容上的需求分析和方案设计，所以在学习的过程要结合这些内容一起来实践，并调试对应的代码。
英语四六级四大题型分类总结资料/笔记（2）：听力
07-22
资料包含：掌握预读技巧，听力需注意14类关键词，听力九大技巧，听力长对话6大边听边记技能，听力五大杀绝，常见场景词汇归纳高频词组，词汇精讲技巧，听力短对话、长对话考试技巧，听力讲义综合笔记（具体和复合，替换题，段子，人物关系，责备场景题，场景题，but题，等），听力技巧等等。
毕业设计javajsp宿舍管理系统ssh源码含文档工具包
07-22
毕业设计javajsp宿舍管理系统ssh源码含文档工具包 后台是ssh框架，页面是jsp，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 宿舍信息系统应该便于院系的宿舍管理，提高工作效率。能有效地对数据进行更新查询，并能在一定程度上实现自动化。 1）本系统的主要功能：学生管理，宿舍公告信息管理，宿舍管理，来访者信息管理，卫生检查信息管理以及保修审批管理。 2）系统性能：应方便快捷地完成宿舍管理的各项工作，数据查询速度快，查询安全、准确，数据合法性检验度高。 3）系统输入：学生的各种信息，包括学号、班级等。 包含：源码、数据库脚本、论文、答辩ppt、开题报告、环境工具包、相同框架项目的安装教程（在说明文档中）
windows本地部署DataX-web
07-22
windows本地部署DataX-web
hdu 2297 run
06-21
HDOJ（ HDU Online Judge）是一个知名的中文编程题库和在线评测系统，题号2297的题目通常会有一个具体的名字，没有直接提供，所以我无法给你详细介绍“run”。不过，我可以给你一般性的描述和可能涉及的编程知识点。 在HDOJ上，一道题目通常包含题目描述、输入输出样例、限制条件等信息。2297可能是一道算法或数据结构题目，比如字符串处理、动态规划、图论、搜索算法等。"run"可能是题目中的关键词，可能表示程序运行过程或要求编写一个能够高效运行的解决方案。 如果你想了解具体的HDOJ 2297，你应该访问HDOJ官网，查看题目详情。在那里，你可以找到详细的题目描述，以及如何使用各种编程语言提交代码并获取运行结果。如果你遇到了编程问题，也可以根据提供的样例测试你的代码，或者查阅官方给定的测试用例和样例解答。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值