char ch; ch=getchar(); // getchar用不了我*** // cin>>ch; while(ch<'0'||ch>'9') ch=getchar(); a[i][j]=ch-'0';为什么getchar用不了

根据您提供的代码，您遇到了无法使用`get()`函数的问题。这可能是因在使用`getchar()`函数之前，标准输入缓冲区中还有其他字符残留，导致`getchar()`读取到了不正确的字符。

为了解决这个问题，您可以在调用`getchar()`之前使用`getchar()`来清空输入缓冲区中的残留字符，直到读取到一个有效的字符为止。修改后的代码如下所示：

char ch;
while ((ch = getchar()) != EOF && ch != '\n'); // 清空输入缓冲区

ch = getchar(); // 读取有效字符
while (ch < '0' || ch > '9')
    ch = getchar();
a[i][j] = ch - '0';

这样，您可以确保在调用`getchar()`函数之前输入缓冲区中没有残留的无效字符。

请注意，`getchar()`函数返回的是`int`类型，而不是`char`类型。这是为了能够表示特殊字符`EOF`（文件结束符）。因此，您可以将其与字符常量`EOF`进行比较，以检查是否达到文件末尾。

如果您还有其他问题，请随时提问。我会尽力帮助您解决问题。

相关问题

满足这是一道 ST 表经典题——静态区间最大值 请注意最大数据时限只有 0.8s，数据强度不低，请务必保证你的每次查询复杂度为 � ( 1 ) O(1)。若使用更高时间复杂度算法不保证能通过。 如果您认为您的代码时间复杂度正确但是 TLE，可以尝试使用快速读入： inline int read() { int x=0,f=1;char ch=getchar(); while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();} while (ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();} return x*f; } 函数返回值为读入的第一个整数。 快速读入作用仅为加快读入，并非强制使用。#include<iostream> #include<cstdio> #include<algorithm> using namespace std; int n[200005], m,a,b,c,d; int correct(int c1, int c2) { int j = 0; for (int i = c1; i <= c2; i++) j = max(n[i], j); return j; } inline int read() { int x = 0, f = 1; char ch = getchar(); while (ch < '0' || ch>'9') { if (ch == '-') f = -1; ch = getchar(); } while (ch >= '0' && ch <= '9') { x = x * 10 + ch - 48; ch = getchar(); } return x * f; } int main() { int i = 1; cin >> a >> b; for(i;i<=a;i++) n[i] = read(); while (b--) { cin >> c >> d; cout << correct(c, d) << endl;; } return 0; }怎么修改

要将上述代码修改为满足题目要求的时间复杂度O(1)，可以使用ST表（Sparse Table）数据结构。以下是修改后的代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 200005;
const int MAXLOG = 20;

int n[MAXN], m, a, b, c, d;
int st[MAXN][MAXLOG];

void initST()
{
    for (int i = 1; i <= a; i++)
        st[i][0] = n[i];

    for (int j = 1; (1 << j) <= a; j++)
    {
        for (int i = 1; i + (1 << j) - 1 <= a; i++)
        {
            st[i][j] = max(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
        }
    }
}

int query(int l, int r)
{
    int k = 0;
    while ((1 << (k + 1)) <= r - l + 1)
        k++;

    return max(st[l][k], st[r - (1 << k) + 1][k]);
}

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - 48;
        ch = getchar();
    }
    return x * f;
}

int main()
{
    int i = 1;
    cin >> a >> b;

    for (i; i <= a; i++)
        n[i] = read();

    initST();

    while (b--)
    {
        cin >> c >> d;
        cout << query(c, d) << endl;
    }
    return 0;
}

在这个修改后的代码中，我们使用ST表数据结构来存储每个区间的最大值。在预处理阶段，我们计算出每个长度为2^j的区间的最大值，并存储在`st`数组中。然后，当需要查询c到d范围内的最大值时，我们根据区间长度选择合适的j值，并使用`st[l][k]`和`st[r - (1 << k) + 1][k]`来获取结果。这样，每次查询的时间复杂度都是O(1)，满足题目要求。

另外，我们还使用了快速读入来加快输入速度，以适应题目给定的时间限制。

#include<iostream> #include<cstdio> #include<algorithm> using namespace std; int n[200005], m,a,b,c,d; int correct(int c1, int c2) { int j = 0; for (int i = c1; i <= c2; i++) j = max(n[i], j); return j; } inline int read() { int x = 0, f = 1; char ch = getchar(); while (ch < '0' || ch>'9') { if (ch == '-') f = -1; ch = getchar(); } while (ch >= '0' && ch <= '9') { x = x * 10 + ch - 48; ch = getchar(); } return x * f; } int main() { int i = 1; cin >> a >> b; for(i;i<=a;i++) n[i] = read(); while (b--) { cin >> c >> d; cout << correct(c, d) << endl;; } return 0; }怎么改成时间复杂度O(1)

要将上述代码的时间复杂度优化为O(1)，可以通过预处理数组来实现。以下是修改后的代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

int n[200005], m, a, b, c, d;
int maxVal[200005];

int correct(int c1, int c2)
{
    return maxVal[c2] - maxVal[c1 - 1];
}

inline int read()
{
    int x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9')
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - 48;
        ch = getchar();
    }
    return x * f;
}

int main()
{
    int i = 1;
    cin >> a >> b;

    for (i; i <= a; i++)
        n[i] = read();

    // 预处理数组，计算从1到i的最大值
    for (int i = 1; i <= a; i++)
        maxVal[i] = max(maxVal[i - 1], n[i]);

    while (b--)
    {
        cin >> c >> d;
        cout << correct(c, d) << endl;;
    }
    return 0;
}

在这个修改后的代码中，我们使用了一个新的数组`maxVal`来存储从1到i的最大值。在预处理阶段，我们计算出每个位置的最大值，并将其存储在`maxVal`数组中。这样，当需要计算c到d范围内的最大值时，我们只需要通过`maxVal[d] - maxVal[c - 1]`来获取结果，而不需要遍历整个范围。这样，时间复杂度就优化为O(1)了。