#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <limits.h>
//宏：
//宏：定义
#define EPS 1e-9
#define MOD 100000000
//宏：类型
#define in int
#define ll long long
#define fl float
#define db double
#define ch char
#define vd void
//宏：函数
#define sc scanf
#define pr printf
//宏：其他
#define rt return
//宏：输入
#define sc_in(x) sc("%d", &(x))
#define sc_ll(x) sc("%lld", &(x))
#define sc_db(x) sc("%lf", &(x))
#define sc_ch(x) sc("%c", &(x))
#define sc_st(str) sc("%s", (str))
//宏：输出（无换行）
#define pr_in(x) pr("%d", x)
#define pr_ll(x) pr("%lld", x)
#define pr_ch(x) pr("%c", x)
#define pr_st(x) pr("%s", x)
//宏：输出（有换行）
#define pr_inn(x) pr("%d\n", x)
#define pr_lln(x) pr("%lld\n", x)
#define pr_chn(x) pr("%c\n", x)
#define pr_stn(x) pr("%s\n", x)
//宏：功能
//浮点相等判断
#define CEPS(a, b) (fabs((a) - (b)) < EPS)
//数组长度获取
#define ArrayNum(x) (sizeof(x)/sizeof(x[0]))
//函数声明：
//函数声明：输入输出辅助
//要求快速输入
in fast_read();
//要求数组输入（一维）
vd scan_arr1(in arr[], in n);
//要求数组输出（一维）
vd print_arr1(in arr[], in n);
//要求数组输入（二维）
vd scan_arr2(in arr[][100], in row, in col);
//要求数组输出（二维）
vd print_arr2(in arr[][100], in row, in col);
//函数声明：数学计算
//求某个数的阶乘（非递归）
ll factorial1(in n);
//求某个数的阶乘（递归）
ll factorial2(in n);
//求斐波那契数列第某个数（非递归）
ll fibonacci1(in n);
//求斐波那契数列第某个数（递归）
ll fibonacci2(in n);
//求斐波那契数列第某个数（递归+优化）
ll fibonacci2_memo(in n);
//求排列数P（n数，排k）
ll permute(in n, in k);
//求组合数C（n数，组k）
ll combine(in n, in k);
//求快速幂（模幂运算）
ll pow_mod(ll base, ll exp);
//求两个数的最大公因数
in gcd(in a, in b);
//求两个数的最小公倍数
in lcm(in a, in b);
//求某个数是否为素数
in is_prime(in n);
//求某个数是否为2的自然数幂
in is_power_2(in x);
//求10进制转<10进制（待拓展）
in digit_change(in n, in digit2);
//求2进制数转10进制数
in bin_to_dec(in bin);
//任意进制转换（2~36）（数组m存储结果）
in char_to_value(ch c);
ch value_to_char(in val);
in convert_base(const ch* n, in a, in b, ch m[]);
//求某个数字的反向输出
in reverse_digits(in n);
//函数声明：字符串处理
//求某个数（字符串形式）是否为回文
in is_palindrome(const ch* s);
//求某个字符串的倒置
vd reverse_string(ch* str);
//求某数是否含某数字（一般数）
in contains_digit1(in n, in p);
//求某数是否含某数字（超大数，%s输入num_str）
in contains_digit2(const ch* num_str, in p);
//求给定字符串出现频次
vd string_frequency(const ch* str);
//函数声明：数组处理
//求某十进制数的各位数
vd extract_digits(in num, in digits[]);
//函数声明：排序搜索
//要求两个整数交换
vd swap(in* a, in* b);
//要求升序排列（冒泡排序）
vd bubble_sort(in* arr, size_t n);
//要求升序排列（快速排序1到r）
vd quick_sort(in arr[], in l, in r);
//要求全排数组（start到end）
vd permute_arr(in arr[], in start, in end);
//要求翻转数组
vd reverse_arr(in arr[], in n);
//求数组某元素的位置（升序，n元，二分找x）
in binary_search(in arr[], in n, in x);
//求区间上零点的位置（单零点，二分，循环）
db binary_solve1(db low, db high);
//求区间上零点的位置（单零点，二分，递归）
db binary_solve2(db low, db high);
//求数组各元素的和
in sum_arr(in arr[], in n);
//求数组最大元素下标
in max_index(in arr[], in n);
//函数声明：几何计算
//求平面上两点的距离
db distance_2d(db x1, db y1, db x2, db y2);
//求三角形的面积（2倍）
ll triange_area_2(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3);
//求凸多边形面积（2倍）
ll n_triangle_area_2(in n, ll x[], ll y[]);
//函数声明：时间日期
//求某年是否为闰年
in is_leap(in year);
//求某年某月的天数
in get_days_of_month(in year, in month);
//求某年某月某日为星期几
in get_week_day(in year, in month, in day);
//函数实现：
//函数实现：输入输出辅助
//要求快速输入
in fast_read()
{
in x = 0, f = 1;
ch c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
//要求数组输入（一维）
vd scan_arr1(in arr[], in n)
{
for (in i = 0; i < n; i++)
{
sc("%d", &arr[i]);
}
}
//要求数组输出（一维）
vd print_arr1(in arr[], in n)
{
for (in i = 0; i < n; i++)
{
pr("%d ", arr[i], " \n"[i == n - 1]);
}
}
//要求数组输入（二维）
vd scan_arr2(in arr[][100], in row, in col)
{
for (in i = 0; i < row; i++)
{
for (in j = 0; j < col; j++)
{
while ((sc_in(arr[i][j])) != 1)
{
while (getchar() != ' ');
}
}
}
}
//要求数组输出（二维）
vd print_arr2(in arr[][100], in row, in col)
{
for (in i = 0; i < row; i++)
{
for (in j = 0; j < col; j++)
{
pr("%d ", arr[i][j]);
}
pr("\n");
}
}
//函数实现：数学计算
//求某个数的阶乘（非递归）
ll factorial1(in n)
{
if (n < 0)
return -1;
if (n > 20)
return -1;
ll result = 1;
for (in i = 2; i <= n; i++)
{
result *= i;
}
return result;
}
//求某个数的阶乘（递归）
ll factorial2(in n)
{
if (n <= 1)
{
return 1;
}
return n * factorial2(n - 1);
}
//求斐波那契数列第某个数（非递归）
ll fibonacci1(in n)
{
if (n == 0) return 0;
if (n == 1) return 1;
ll prev = 0;
ll curr = 1;
ll next;
for (in i = 2; i <= n; i++) {
next = prev + curr;
prev = curr;
curr = next;
}
return curr;
}
//求斐波那契数列第某个数（递归）
ll fibonacci2(in n)
{
if (n == 0)
{
return 0;
}
else if (n == 1 || n == 2)
{
return 1;
}
return fibonacci2(n - 1) + fibonacci2(n - 2);
}
//求斐波那契数列第某个数（递归+优化）
ll memo[1000] = { 0 };
ll fibonacci2_memo(in n)
{
if (n == 1 || n == 2)
{
return 1;
}
if (memo[n] != 0)
{
return memo[n];
}
memo[n] = fibonacci2_memo(n - 1) + fibonacci2_memo(n - 2);
return memo[n];
}
//求排列数P（n数，排k）
ll permute(in n, in k)
{
if (k < 0 || n < 0 || k > n)
{
return -1;
}
ll result = 1;
for (in i = n - k + 1; i <= n; i++)
{
result *= i;
}
return result;
}
//求组合数C（n数，组k）
ll combine(in n, in k)
{
if (k < 0 || n < 0 || k > n)
{
return -1;
}
if (k > n - k)
{
k = n - k;
}
ll result = 1;
for (in i = 0; i < k; i++)
{
result = result * (n - i) / (i + 1);
}
return result;
}
//求快速幂（模幂运算）
ll pow_mod(ll base, ll exp)
{
ll result = 1;
while (exp > 0)
{
if (exp & 1)
{
result = (result * base) % MOD;
}
base = (base * base) % MOD;
exp >>= 1;
}
return result;
}
//求两个数的最大公因数
in gcd(in a, in b)
{
if (a < 0)
a = -a;
if (b < 0)
b = -b;
while (b != 0)
{
in temp = b;
b = a % b;
a = temp;
}
return a;
}
//求两个数的最小公倍数
in lcm(in a, in b)
{
return a / gcd(a, b) * b;
}
//求某个数是否为素数
in is_prime(in n)
{
if (n <= 1)
{
return 0;
}
else if (n <= 3)
{
return 1;
}
else if (n % 2 == 0 || n % 3 == 0)
{
return 0;
}
for (in i = 5; i * i <= n; i += 6)
{
if (n % i == 0 || n % (i + 2) == 0)
{
return 0;
}
}
return 1;
}
//求某个数是否为2的自然数幂
in is_power_2(in x)
{
return x > 0 && (x & (x - 1)) == 0;
}
//求10进制转<10进制（待拓展）
in digit_change(in n, in digit2)
{
in rem = n;
in mod[100];
in i = 0;
while (rem > 0)
{
mod[i] = rem % digit2;
rem = rem / digit2;
i++;
}
in result = 0;
in ten = 1;
for (in j = 0; j < i; j++)
{
result += mod[j] * ten;
ten = 10 * ten;
}
return result;
}
//求2进制数转10进制数
in bin_to_dec(in bin) {
if (bin == 0)
{
return 0;
}
if (bin < 0)
{
return -1;
}
in decimal = 0;
in base = 1;
while (bin > 0)
{
in digit = bin % 10;
if (digit != 0 && digit != 1)
{
return -1;
}
decimal += digit * base;
base *= 2;
bin /= 10;
}
return decimal;
}
//任意进制转换（2~36）（数组m存储结果）
in char_to_value(ch c)
{
if (isdigit(c)) return c - '0';
if (isupper(c)) return c - 'A' + 10;
if (islower(c)) return c - 'a' + 10;
return -1;
}
ch value_to_char(in val)
{
if (val < 10) return '0' + val;
return 'A' + val - 10;
}
in convert_base(const ch* n, in a, in b, ch m[])
{
if (!n || !m || a < 2 || a > 36 || b < 2 || b > 36)
{
m[0] = '\0';
return -1;
}
in len = strlen(n);
if (len == 0)
{
m[0] = '0';
m[1] = '\0';
return 0;
}
ll decimal = 0;
for (in i = 0; i < len; i++)
{
in val = char_to_value(n[i]);
if (val == -1 || val >= a)
{
m[0] = '\0';
return -1;
}
decimal = decimal * a + val;
}
if (decimal == 0)
{
m[0] = '0';
m[1] = '\0';
return 0;
}
ch temp[65];
in idx = 0;
while (decimal > 0)
{
in r = decimal % b;
temp[idx++] = value_to_char(r);
decimal /= b;
}
temp[idx] = '\0';
for (in i = 0; i < idx; i++)
{
m[i] = temp[idx - 1 - i];
}
m[idx] = '\0';
return 0;
}
//求某个数字的反向输出
in reverse_digits(in n)
{
in digits[10] = { 0 };
in i = 0;
in num = n;
while (num > 0)
{
digits[i++] = num % 10;
num /= 10;
}
in ans = 0;
for (in j = 0; j < i; j++)
{
ans = ans * 10 + digits[j];
}
return ans;
}
//函数实现：字符串处理
//求某个数（字符串形式）是否为回文
in is_palindrome(const ch* s)
{
if (s == NULL)
{
return 0;
}
in left = 0;
in right = strlen(s) - 1;
while (left < right)
{
if (tolower(s[left]) != tolower(s[right]))
{
return 0;
}
left++;
right--;
}
return 1;
}
//求某个字符串的倒置
vd reverse_string(ch* str)
{
if (str == NULL)
{
return;
}
in left = 0;
in right = strlen(str) - 1;
ch temp;
while (left < right)
{
temp = str[left];
str[left] = str[right];
str[right] = temp;
left++;
right--;
}
}
//求某数是否含某数字（一般数）
in contains_digit1(in n, in p)
{
ch str[50];
ch target = '0' + p;
sprintf(str, "%d", n);
for (in i = 0; str[i] != '\0'; i++)
{
if (str[i] == target)
{
return 1;
}
}
return 0;
}
//求某数是否含某数字（超大数，%s输入num_str）
in contains_digit2(const ch* num_str, in p)
{
ch target = '0' + p;
for (in i = 0; num_str[i] != '\0'; i++)
{
if (num_str[i] < '0' || num_str[i] > '9')
{
continue;
}
if (num_str[i] == target)
{
return 1;
}
}
return 0;
}
//求给定字符串出现频次
vd string_frequency(const ch* str)
{
in freq[128] = { 0 };
for (in i = 0; str[i] != '\0'; i++)
{
unsigned ch c = str[i];
if (c == ' ' || isprint(c))
{
freq[c]++;
}
}
int count = 0;
for (in i = 0; i < 128; i++)
{
if (freq[i] > 0)
{
count++;
if (i == ' ')
{
pr("blank: %d\n", freq[i]);
}
else
{
pr("'%c': %d\n", i, freq[i]);
}
}
}
}
//函数实现：数组处理
//求某十进制数的各位数
vd extract_digits(in num, in digits[])
{
if (num == 0)
{
digits[0] = 0;
digits[1] = -1;
return;
}
in i = 0;
while (num > 0)
{
digits[i++] = num % 10;
num /= 10;
}
}
//函数实现：排序搜索
//要求两个整数交换
vd swap(in* a, in* b)
{
in temp = *a;
*a = *b;
*b = temp;
}
//要求升序排列（冒泡排序）
vd bubble_sort(in* arr, size_t n)
{
if (arr == NULL || n < 2)
{
return;
}
for (size_t i = 0; i < n - 1; i++)
{
in swapped = 0;
for (size_t j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
in temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = 1;
}
}
if (!swapped)
{
break;
}
}
}
//要求升序排列（快速排序1到r）
vd quick_sort(in arr[], in l, in r)
{
if (l >= r)
{
return;
}
in i = l, j = r;
in pivot = arr[(l + r) / 2];
while (i <= j)
{
while (arr[i] < pivot) i++;
while (arr[j] > pivot) j--;
if (i <= j)
{
swap(&arr[i], &arr[j]);
i++;
j--;
}
}
quick_sort(arr, l, j);
quick_sort(arr, i, r);
}
//要求全排数组（start到end）
vd permute_arr(in arr[], in start, in end)
{
if (start == end)
{
for (in i = 0; i <= end; i++)
{
pr("%d ", arr[i]);
}
pr("\n");
}
else
{
for (in i = start; i <= end; i++)
{
swap(&arr[start], &arr[i]);
permute_arr(arr, start + 1, end);
swap(&arr[start], &arr[i]);
}
}
}
//要求翻转数组
vd reverse_arr(in arr[], in n)
{
for (in i = 0; i < n / 2; i++)
{
in t = arr[i];
arr[i] = arr[n - 1 - i];
arr[n - 1 - i] = t;
}
}
//求数组某元素的位置（升序，n元，二分找x）
in binary_search(in arr[], in n, in x)
{
in left = 0, right = n - 1;
while (left <= right)
{
in mid = (left + right) / 2;
if (arr[mid] == x)
{
return mid;
}
else if (arr[mid] < x)
{
left = mid + 1;
}
else right = mid - 1;
}
return -1;
}
//求区间上零点的位置（单零点，二分，循环）
db f1(db x)
{
return sin(x);
}
db binary_solve1(db low, db high)
{
db mid;
while (high - low >= EPS)
{
mid = low + (high - low) / 2;
f1(mid) > 0 ? (high = mid) : (low = mid);
}
return low + (high - low) / 2;
}
//求区间上零点的位置（单零点，二分，递归）
db f2(db x)
{
return sin(x);
}
db binary_solve2(db low, db high)
{
db mid = low + (high - low) / 2;
if (high - low < EPS)
{
return mid;
}
else if (f2(mid) > 0)
{
return binary_solve2(low, mid);
}
else
{
return binary_solve2(mid, high);
}
}
//求数组各元素的和
in sum_arr(in arr[], in n)
{
in s = 0;
for (in i = 0; i < n; i++)
{
s += arr[i];
}
return s;
}
//求数组最大元素下标
in max_index(in arr[], in n)
{
in idx = 0;
for (in i = 1; i < n; i++)
{
if (arr[i] > arr[idx])
{
idx = i;
}
}
return idx;
}
//函数实现：几何计算
//求平面上两点的距离
db distance_2d(db x1, db y1, db x2, db y2)
{
db dx = x2 - x1;
db dy = y2 - y1;
return sqrt(dx * dx + dy * dy);
}
//求三角形的面积（2倍）
ll triange_area_2(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3)
{
ll area_2 = (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1);
return area_2 < 0 ? -area_2 : area_2;
}
//求凸多边形面积（2倍）
ll n_triangle_area_2(in n, ll x[], ll y[])
{
ll area_2 = 0;
for (in i = 0; i < n; i++)
{
in j = (i + 1) % n;
area_2 += x[i] * y[j] - x[j] * y[i];
}
return area_2 > 0 ? area_2 : -area_2;
}
//函数实现：时间日期
//求某年是否为闰年
in is_leap(in year)
{
return (year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0);
}
//求某年某月的天数
in get_days_of_month(in year, in month)
{
in days = 0;
switch (month)
{
case 1: case 3: case 5: case 7: case 8: case 10: case 12:
days = 31;
break;
case 4: case 6: case 9: case 11:
days = 30;
break;
case 2:
days = is_leap(year) ? 29 : 28;
break;
}
return days;
}
//求某年某月某日为星期几
in get_week_day(in year, in month, in day)
{
in century, weekday;
if (month < 3)
{
year--;
month += 12;
}
century = year / 100;
year %= 100;
weekday = (year + year / 4 + century / 4 - 2 * century + (26 * (month + 1)) / 10 + day - 1) % 7;
if (weekday < 0)
{
weekday += 7;
}
return weekday;
}优化下界面方便我检索
本文深入解析了快速幂算法，一种高效计算x的n次幂的方法，尤其适用于大指数的情况。文章通过实例展示了如何使用二分查找和递归思想简化计算过程，降低时间复杂度至O(logn)。同时，讨论了当n为负数时的处理技巧，并提供了C++代码实现。
扫一扫
825
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
