在Android上使用OpenCV

最近的项目有可能使用到OpenCV,因此了解了一下Android上如何配置OpenCV
前提:已经在eclipse上配置好了android sdk
需要下载的资源:http://sourceforge.net/projects/opencvlibrary/files/opencv-android/2.4.0/OpenCV-2.4.0-android-bin.tar.bz2/download
这个是需要的android源码包 里面有examples 和 tutorial
步骤比较简单
1.下载资源包,解压缩文件,位置随意啦
2.在eclipse里面import existing project



3.修复错误
完成后提示以下错误…

常见错误
Unable to resolve target ‘android-9′  没有安装对应的android sdk
方法 安装该sdk 但是貌似没有。。。那就把project.properities修改成如下情况 比如我安装了4.0.3sdk 即api-15

修改完了之后如果提示
Android requires compiler compliance level 5.0 or 6.0. Found ’1.7′ instead. Please use Android Tools > Fix Project Properties.
照着做就行了
如果出现OpenCV中的那些类提示找不到 可以考虑修改工程里面的
android.library.reference.1=../../OpenCV-2.4.0/ 里面的路径
我上次配置的时候就改成这样 android.library.reference.1=../../../OpenCV-2.4.0/
至此就能使用了

HDU 3713 Double Maze

代码写了很久才调通——!双迷宫搜索 不过状态数不大 只有6^4次 主要是地图的处理 以及居然要相邻两个地图都要求解一次 还有用到掩码也就是位运算来确定当前位置的四个方向是否有墙以及是否是洞…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include <stdio.h>
#include <string.h>
#include <stack>
using std::stack;
int hash[6][6][6][6], dirx[] = {0,1,0,-1}, diry[] = {-1,0,1,0}, map1[6][6], map2[6][6], choice[4] = {1,0,2,3};
char dirc[] = "LDRU";
struct Point
{
    int x, y;
    void operator = (const Point & p)
    {
        x = p.x;
        y = p.y;
    }
    bool operator == (const Point & p)
    {
        return x == p.x && y == p.y;
    }
}pnt[2];
struct State
{
    Point a, b;
    int father, drt;
    bool operator == (const State &cmp)
    {
        return a == cmp.a && b == cmp.b;
    }
    bool valid()
    {
        return (map1[a.x][a.y] & (1<< 4)) != 0&& (map2[b.x][b.y] & (1<< 4)) != 0 && a.x >= 0 && a.y >= 0 && b.x >= 0 && b.y >=0 && a.x < 6 && a.y < 6 && b.x < 6 && b.y < 6;
    }
    State trans(int dir, int idx)
    {
        State ret;
        ret.drt = dir;
        ret.father = idx;
        if((map1[a.x][a.y] & (1 << dir)) == 0)
        {
            ret.a.x = a.x + dirx[dir];
            ret.a.y = a.y + diry[dir];
        }
        else
        {
            ret.a.x = a.x;
            ret.a.y = a.y;
        }
        if((map2[b.x][b.y] & (1 << dir)) == 0)
        {
            ret.b.x = b.x + dirx[dir];
            ret.b.y = b.y + diry[dir];
        }
        else
        {
            ret.b.x = b.x;
            ret.b.y = b.y;
        }
        return ret;
    }
    void set(Point p1, Point p2)
    {
        a = p1, b = p2;
    }
    State()
    {
        father = -1;
    }
}s1,s2,tmp,queue[1300],ns;
inline void makehash(State s)
{
    hash[s.a.x][s.a.y][s.b.x][s.b.y] = 1;
}
inline bool checkhash(State s)
{
    return hash[s.a.x][s.a.y][s.b.x][s.b.y] == 0;
}
void read(int map[6][6])
{
    for(int i = 0; i < 6; ++ i)
    for(int j = 0; j < 6; ++ j)
    {
        scanf("%d",map[i]+j);
        if((map[i][j] &(1 << 5)) != 0) pnt[0].x = i, pnt[0].y = j;
        if((map[i][j] & (1 << 6)) != 0) pnt[1].x = i, pnt[1].y = j;
    }
}
int main()
{
    int n, head, tail;
    scanf("%d", &n);
    read(map1);
    s1.a = pnt[0];
    s2.a = pnt[1];
    while(--n)
    {
        memset(hash, 0, sizeof(hash));
        stack<char> stk;
        read(map2);
        s1.b = pnt[0];
        s2.b = pnt[1];
        head = tail = 0;
        queue[tail++] = s1;
        makehash(s1);
        while(head < tail)
        {
            tmp = queue[head];
            if(tmp == s2)
            {
                for(int f = head; f > 0; f = queue[f].father)
                stk.push(dirc[queue[f].drt]);
                while(!stk.empty())
                {
                    putchar(stk.top());
                    stk.pop();
                }
                puts("");
                break;
            }
            for(int i = 0; i < 4; ++ i)
            {
                ns = tmp.trans(choice[i], head);
                if(ns.valid() && checkhash(ns))
                {
                    queue[tail++] = ns;
                    makehash(ns);
                }
            }
            ++ head;
        }
        if(head >= tail) puts("-1");
        memcpy(map1, map2, sizeof(map1));
        s1.a = s1.b;
        s2.a = s2.b;
    }
    return 0;
}

2011 ACM/ICPC 北京现场赛J题 dfs剪枝

游戏规则是Same Gnome的变形 自身是个NP问题 所以只能暴力
为了能比较快的求解 所以规定了8连通以及至少要3块以上才能消去
一开始以为纯暴力 但是发现tle 所以想了一个自己认为比较弱的剪枝 统计每个数字出现的次数 消去一连通块之后 更新出现的该数字出现的次数 然后将score + 该连通块能得到的分数 + 剩下连通块能得到的最多的分数 与当前max值比较 如果大于max值则继续搜索 否则不拓展当前节点 加上这个优化之后居然2.+s就ac了 稍微修改了一些不必要的参数 下面的程序只用1.6s就能跑完数据 据说还有状态压缩的优化 表示不会了… 另外要注意memcpy的时候不要把形参当作sizeof的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#include <stdio.h>
#include <string.h>
int m, n, k, max, hash[7], mat[8][8], tmat[8][8], dir[3]= {-1,0,1};
struct Point
{
    int x, y;
    inline void set(int a, int b)
    {
        x = a, y = b;
    }
};
int evaluate()//估值函数
{
    int eval = 0;
    for(int i = 1; i <= k; ++ i)
        eval +=  hash[i] * hash[i];
    return eval;
}
void modify()//方块的左移和掉落
{
    int head;
    for(int i = 0; i < m; ++ i)
    {
        head = n - 1;
        while(head >= 0)
        {
            if(mat[head][i] == 0) break;
            else -- head;
        }
        if(head > 0)
        {
            for(int j = head - 1; j >= 0; -- j)
                if(mat[j][i] != 0)
                {
                    mat[head--][i] = mat[j][i];
                    mat[j][i] = 0;
                }
        }
    }
    bool zerocol;
    for(head = 0; head < m ; ++ head)
    {
        zerocol = true;
        for(int i = 0; i < n; ++ i)
            if(mat[i][head] != 0) zerocol = false;
        if(zerocol) break;
    }
    if(head < m - 1)
    {
        for(int i = head + 1; i  < m; ++ i)
        {
            zerocol = true;
            for(int j = 0; j < n; ++ j)
                if(mat[j][i] != 0) zerocol = false;
            if(!zerocol)
            {
                for(int j = 0; j < n; ++ j)
                {
                    mat[j][head] = mat[j][i];
                    mat[j][i] = 0;
                }
                ++ head;
            }
        }
    }
}
int travese(int x, int y, int mat[8][8], int val)//在mat上将和(x,y)点值相同且(x,y)连通的点标记成val
{
    Point queue[64], tmp;
    int head = 0, tail = 0, v = mat[x][y];
    queue[tail++].set(x,y);
    mat[x][y] = val;
    while(head < tail)
    {
        tmp = queue[head++];
        for(int i = 0; i < 3; ++ i)
            for(int j = 0; j < 3; ++ j)
            {
                if(mat[tmp.x + dir[i]][tmp.y + dir[j]] == v && tmp.x + dir[i] >= 0 && tmp.x + dir[i] < n && tmp.y + dir[j] >= 0 && tmp.y + dir[j] < m)
                {
                    mat[tmp.x + dir[i]][tmp.y + dir[j]] = val;
                    queue[tail++].set(tmp.x + dir[i] , tmp.y + dir[j]);
                }
            }
    }
    return tail;
}
int link(Point * p)
{
    memcpy(tmat, mat, sizeof(tmat));
    int cnt = 0;
    for(int i  = 0; i < n; ++ i)
        for(int j = 0; j < m; ++ j)
        {
            if(tmat[i][j] > 0)
            {
                if(travese(i,j,tmat,-1)>= 3)
                    p[cnt++].set(i,j);
            }
        }
    return cnt;
}
void dfs(int score)//暴力搜索
{
    Point pnt[21];
    int cnt = link(pnt);
    if(cnt == 0)
        max = max > score ? max : score;
    else
    {
        int ta[8][8];
        for(int i = 0; i < cnt; ++ i)
        {
            memcpy(ta, mat, sizeof(ta));
            int t = travese(pnt[i].x, pnt[i].y, mat, 0);
            hash[ta[pnt[i].x][pnt[i].y]]-= t;
            if(evaluate() + score + t * t > max)//估值函数
            {
                modify();
                dfs(score+ t * t);
            }
            hash[ta[pnt[i].x][pnt[i].y]]+= t;
            memcpy(mat, ta, sizeof(ta));
        }
    }
}
int main()
{
    while(scanf("%d%d%d", &n, &m , & k) != EOF)
    {
        memset(hash,0,sizeof(hash));
        for(int i = 0; i < n; ++ i)
            for(int j = 0; j < m; ++ j)
            {
                scanf("%d", mat[i]+j);
                ++hash[mat[i][j]];
            }
        max = 0;
        dfs(0);
        printf("%d\n",max);
    }
    return 0;
}

Gauss XOR Elimination Template

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
int gauss_XOR_Elimination(int aug_mat[MAXN][MAXN], int sol_vec[MAXN], int equ, int var)
{
    int row, col, max_row, tmp;
    for(row = col = 0; row < equ && col < var; ++ row , ++col)
    {
        max_row = row;
        for(int i = row + 1; i < equ; ++ i)
            max_row = mabs(aug_mat[max_row][col]) > mabs(aug_mat[i][col]) ? max_row : i;
        if(aug_mat[max_row][col] == 0) --row;
        else
        {
            for(int i = col; i <= var; ++ i)
            {
                tmp = aug_mat[max_row][i];
                aug_mat[max_row][i] = aug_mat[row][i];
                aug_mat[row][i] = tmp;
            }
            for(int i = row + 1; i < equ; ++ i)
                if(aug_mat[i][col])
                    for(int j = col; j < var + 1; ++ j)
                        aug_mat[i][j] ^= aug_mat[row][j];
        }
    }
    for(int i = row; i < equ; ++ i)
    if(aug_mat[i][var]) return -1;
    if(row < var) return var - row;
    else
    {
        for(int i = row - 1; i >= 0; -- i)
        {
            sol_vec[i] = aug_mat[i][var];
            for(int j = i - 1; j >= 0; -- j)
            if(aug_mat[j][i])
            aug_mat[j][var] ^= sol_vec[i];
        }
        return 0;
    }
}

经过弱数据检验 正在准备用强数据来检验

HDU 2449 Gauss Elimination

言简意赅 高斯消元 按照题目给点数据范围是很有可能超过long long的 但是实际的数据范围比较水…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
import java.util.Scanner;
import java.math.BigInteger;
public class Main {
    static class Fraction
    {
        static Fraction ZERO = new Fraction(BigInteger.ZERO, BigInteger.ONE);
        BigInteger numerator,denominator;
        Fraction()
        {
            numerator = BigInteger.ZERO;
            denominator = BigInteger.ONE;
        }
        void simplify()
        {
            BigInteger g = numerator.gcd(denominator);
            numerator = numerator.divide(g);
            denominator = denominator.divide(g);
            if(denominator.compareTo(BigInteger.ZERO) < 0)
            {
                denominator = denominator.multiply(new BigInteger("-1"));
                numerator = numerator.multiply(new BigInteger("-1"));
            }
        }
        Fraction(BigInteger numer)
        {
            numerator = numer;
            denominator = BigInteger.ONE;
        }
        Fraction(BigInteger numer, BigInteger deno)
        {
            if(deno.compareTo(BigInteger.ZERO) >= 0)
            {
                numerator = numer;
                denominator = deno;
            }
            else
            {
                numerator = numer.multiply(new BigInteger("-1"));
                denominator =  deno.multiply(new BigInteger("-1"));
            }
        }
        Fraction(Fraction copy)
        {
            numerator = new BigInteger(copy.numerator.toString());
            denominator = new BigInteger(copy.denominator.toString());
        }
        Fraction subtract(Fraction sub)
        {
            BigInteger g = denominator.gcd(sub.denominator);
            Fraction ret = new Fraction();
            ret.denominator = sub.denominator.divide(g).multiply(denominator);
            ret.numerator = numerator.multiply(sub.denominator.divide(g)).subtract(sub.numerator.multiply(denominator.divide(g)));
            simplify();
            return ret;
        }
        Fraction add(Fraction ad)
        {
            BigInteger g = denominator.gcd(ad.denominator);
            Fraction ret = new Fraction();
            ret.denominator = ad.denominator.divide(g).multiply(denominator);
            ret.numerator = numerator.multiply(ad.denominator.divide(g)).add(ad.numerator.multiply(denominator.divide(g)));
            simplify();
            return ret;
        }
        Fraction multiply(Fraction mult)
        {
            Fraction ret = new Fraction();
            ret.denominator = denominator.multiply(mult.denominator);
            ret.numerator = numerator.multiply(mult.numerator);
            ret.simplify();
            return ret;
        }
        Fraction divide(Fraction div)
        {
            Fraction ret = new Fraction();
            ret.denominator = denominator.multiply(div.numerator);
            ret.numerator = numerator.multiply(div.denominator);
            ret.simplify();
            return ret;
        }
        int compareTo(Fraction cmp)
        {
            return this.subtract(cmp).numerator.compareTo(BigInteger.ZERO);
        }
        Fraction abs()
        {
            Fraction ret = new Fraction(this);
            ret.numerator = ret.numerator.abs();
            return ret;
        }
        public String toString()
        {
            if(denominator.equals(BigInteger.ONE)) return numerator.toString();
            else return numerator.toString()+"/"+denominator.toString();
        }
    }
    // matrix[equ][var+1] squar matrix is not recommended
    static int guass_Elimination(Fraction[][] mat, Fraction[] sol_vec, int equ, int var)
    {
        Fraction tmp;
        // get a stiangle maxtrix 
        int row =0, col = 0;
        for(int max_row; row < equ && col < var ; ++ row, ++ col)
        {
            max_row = row;
            //Find The row of the Max Abs value of current column
            for(int i = row + 1; i < equ; ++ i)
                if(mat[max_row][col].abs().compareTo(mat[i][col].abs()) < 0) max_row = i;
            //if max abs value of current column is zero means all the variables of this column equal to zero
            // which means we should elimination the next column
            // in this program we decrease row by 1 to archieve this goal
            if(mat[max_row][col].compareTo(Fraction.ZERO) == 0)
                -- row;
            else
            {
                //Swap the max row with current row
                for (int i = col; i <= var; ++i)
                {
                    tmp = mat[row][i];
                    mat[row][i] = mat[max_row][i];
                    mat[max_row][i] = tmp;
                }
                //Elimination
                for(int i = row + 1; i < equ; ++ i)
                {
                    if(mat[i][col].compareTo(Fraction.ZERO) != 0)
                    {
                        tmp = mat[i][col].divide(mat[row][col]);
                        for(int j = col; j <= var; ++ j)
                        mat[i][j] = mat[i][j].subtract(mat[row][j].multiply(tmp));
                    }
                }
            }
        }
        for(int i  =row; i < equ; ++ i)
            if(mat[i][var].compareTo(Fraction.ZERO) != 0) return -1;
        if( row < var ) return var - row;
        else
        {
            for(int i = 0; i < equ; ++ i)
            {
                for(int j = 0; j < i; ++ j)
                    mat[equ-1-i][var] = mat[equ-1-i][var].subtract(mat[equ-1-i][var - 1 - j].multiply(sol_vec[var - 1 - j]));
                sol_vec[var-1-i] = mat[equ-1-i][var].divide(mat[equ-1-i][equ-1-i]);
            }
            return 0;
        }
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        BigInteger t;
        Fraction frac[][] = new Fraction[110][111];
        Fraction sol_vec[] = new Fraction[110];
        int n;
        while(scan.hasNext())
        {
            n = scan.nextInt();
            for(int i = 0; i < n; ++ i)
                for(int j = 0; j < n + 1; ++ j)
                    frac[i][j] =new Fraction(scan.nextBigInteger());
            if(guass_Elimination(frac,sol_vec,n,n) == 0)
            {
                for(int i = 0; i < n; ++ i)
                    System.out.println(sol_vec[i].toString());
                System.out.println("");
            }
            else 
            {
                System.out.println("No solution.");
                System.out.println("");
            }
        }
    }
}

Java 大数分数模板[Testing]

略水的大分数模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
static class Fraction
    {
        static Fraction ZERO = new Fraction(BigInteger.ZERO, BigInteger.ONE);
        BigInteger numerator,denominator;
        Fraction()
        {
            numerator = BigInteger.ZERO;
            denominator = BigInteger.ONE;
        }
        void simplify()
        {
            BigInteger g = numerator.gcd(denominator);
            numerator = numerator.divide(g);
            denominator = denominator.divide(g);
            if(denominator.compareTo(BigInteger.ZERO) < 0)
            {
                denominator = denominator.multiply(new BigInteger("-1"));
                numerator = numerator.multiply(new BigInteger("-1"));
            }
        }
        Fraction(BigInteger numer)
        {
            numerator = numer;
            denominator = BigInteger.ONE;
        }
        Fraction(BigInteger numer, BigInteger deno)
        {
            if(deno.compareTo(BigInteger.ZERO) >= 0)
            {
                numerator = numer;
                denominator = deno;
            }
            else
            {
                numerator = numer.multiply(new BigInteger("-1"));
                denominator =  deno.multiply(new BigInteger("-1"));
            }
        }
        Fraction(Fraction copy)
        {
            numerator = new BigInteger(copy.numerator.toString());
            denominator = new BigInteger(copy.denominator.toString());
        }
        Fraction subtract(Fraction sub)
        {
            BigInteger g = denominator.gcd(sub.denominator);
            Fraction ret = new Fraction();
            ret.denominator = sub.denominator.divide(g).multiply(denominator);
            ret.numerator = numerator.multiply(sub.denominator.divide(g)).subtract(sub.numerator.multiply(denominator.divide(g)));
            simplify();
            return ret;
        }
        Fraction add(Fraction ad)
        {
            BigInteger g = denominator.gcd(ad.denominator);
            Fraction ret = new Fraction();
            ret.denominator = ad.denominator.divide(g).multiply(denominator);
            ret.numerator = numerator.multiply(ad.denominator.divide(g)).add(ad.numerator.multiply(denominator.divide(g)));
            simplify();
            return ret;
        }
        Fraction multiply(Fraction mult)
        {
            Fraction ret = new Fraction();
            ret.denominator = denominator.multiply(mult.denominator);
            ret.numerator = numerator.multiply(mult.numerator);
            ret.simplify();
            return ret;
        }
        Fraction divide(Fraction div)
        {
            Fraction ret = new Fraction();
            ret.denominator = denominator.multiply(div.numerator);
            ret.numerator = numerator.multiply(div.denominator);
            ret.simplify();
            return ret;
        }
        int compareTo(Fraction cmp)
        {
            return this.subtract(cmp).numerator.compareTo(BigInteger.ZERO);
        }
        Fraction abs()
        {
            Fraction ret = new Fraction(this);
            ret.numerator = ret.numerator.abs();
            return ret;
        }
        public String toString()
        {
            if(denominator.equals(BigInteger.ONE)) return numerator.toString();
            else return numerator.toString()+"/"+denominator.toString();
        }
    }

HDU 1299 Diophantus of Alexandria[EASY]

要求满足 1/x + 1/y = 1/n x,y,n都为正整数 的方程的方案数 这题自己没有想出来 上网参考别人的想法的
首先,可以知道x > n, y > n, y = n + k,带入式子,化简后得到 x = n*n/k + n,先不考虑x,y的大小关系,显然x为整数,因此有多少个x对应就有多少式子是符合题意的 但是要注意! 会出现重复计数,因为x,y在式子中是等价的,因此绝大多数的式子被记录了两次 例如n = 4时 k 可以等于 1,2,4,8,16 得到对应的x是 20,12,8,6,5;对应的y为 5,6,8,12,20,发现除了 k=n的时候的式子 也就是 1/n = 1/2n + 1/2n的式子,其余的式子都被计数了2次,因此需要算出n*n的因子数加一除以2
接下来就是求n*n的因子数了,根据题目数据范围n×n可以达到10^18 因此直接算n*n的因子数素数表大小是装不下的,所以直接对n进行素因子分解,
n = p1^r1 * p2^r2 * p3 &r3 * …pi^ri n的所有因子数是(r1+1)*(r2+1)*…*(ri+1)
n*n的所有因子数就是(2×r1+1)*(2×r2+1)*…*(2×ri+1)
至此,题目就解决了~当然少不了犀利的筛素数模板了~~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <stdio.h>
#include <string.h>
const int PRIMERANGE = 40000;
int prime[PRIMERANGE + 1];
int getPrime()
{
    memset (prime, 0, sizeof (int) * (PRIMERANGE + 1));
    for (int i = 2; i <= PRIMERANGE; i++)
    {
        if (!prime[i]) prime[++prime[0]] = i;
        for (int j = 1; j <= prime[0] && prime[j] <= PRIMERANGE / i; j++)
        {
            prime[prime[j]*i] = 1;
            if (i % prime[j] == 0) break;
        }
    }
    return prime[0];
}
int factor[100][3], facCnt;
int getFactors(int x)
{
    facCnt = 0;
    int tmp = x;
    for(int i = 1; prime[i] <= tmp / prime[i]; i++)
    {
        factor[facCnt][1] = 1, factor[facCnt][2] = 0;
        if(tmp % prime[i] == 0)
            factor[facCnt][0] = prime[i];
        while(tmp % prime[i] == 0)
            factor[facCnt][2]++, factor[facCnt][1] *= prime[i], tmp /= prime[i];
        if(factor[facCnt][1] > 1) facCnt++;
    }
    if(tmp != 1)
        factor[facCnt][0] = tmp, factor[facCnt][1] = tmp, factor[facCnt++][2] = 1;
    return facCnt;
}
int main()
{
    int t,n, ans;
    getPrime();
    scanf("%d", & t);
    for(int c = 1; c <= t; ++ c)
    {
        scanf("%d", & n);
        getFactors(n);
        ans = 1;
        for(int i = 0; i < facCnt; ++ i)
            ans *= (((factor[i][2])<< 1) + 1);
        printf("Scenario #%d:\n%d\n\n", c, (ans+1) >> 1);
    }
    return 0;
}

HDU 1211 RSA[EASY]

一个模拟题 而且数据范围貌似还水了 int居然就能过了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
int main()
{
    long long n,fn;
    int p, q, e, l, d, c, tmp, t, ans;
    while(scanf("%d%d%d%d",&p,&q,&e,&l) != EOF)
    {
        fn = (p - 1) * (q - 1);
        n = p * q;
        for(d = 1; (e*d) % fn != 1; ++d);
        while(l --)
        {
            scanf("%d", & c);
            for(tmp = c, t = d, ans = 1; t ; t >>= 1)
            {
                if(t & 1) ans = (ans * tmp) % n;
                tmp = (tmp * tmp) % n;
            }
            putchar(ans);
        }
        puts("");
    }
    return 0;
}

HDU 1153 Magic Bitstrings [Unknown]

没看懂题意..所以不算解决这个问题了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <string.h>
char ans[100001];
int main()
{
    long long n;
    while(scanf("%lld",&n),n)
    {
        if(n == 2) puts("Impossible");
        else
        {
            long long i;
            memset(ans,'1',(n+1)*sizeof(char));
            ans[n] = 0;
            for(i = 1 ; i < n ; i++) ans[i*i%n] = '0';
            puts(ans+1);
        }
    }
    return 0;
}

HDU 1121 Factorial[EASY]

简单的求阶乘0的个数 直接用迭代数有几个5

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
int main()
{
    int n, ans, t;
    scanf("%d", & t);
    while(t--)
    {
        scanf("%d",&n);
        for(ans = 0; n ; ans+= n / 5, n /= 5);
        printf("%d\n",ans);
    }
    return 0;
}
←Older