50pts:
由于只有一行，用一维数组扫一遍即可。
实际上好像能过80pts，只能说数据水了...

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m;
    cin>>n>>m;
    int a[m+1]; 
    for(int i=1;i<=m;i++) cin>>a[i];
    for(int i=1;i<=m;i++) 
        if(i==m || a[i]>=a[i+1]){cout<<i-1;break;}
}

140pts:
经典的dfs的方法探索迷宫，由于这张图一定没有环，所以连vis数组都不需要使用。

#include<bits/stdc++.h>
using namespace std;
int a[1005][1005], n, m, ans = 0;
int d[4][2] = {
    0,1,
    1,0,
    -1,0,
    0,-1
};
void dfs(int x, int y, int val)
{
    ans = max(ans, val);
    for(int i=0;i<4;i++)
    {
        int dx = x+d[i][0], dy = y+d[i][1];
        if(dx<=0 || dx>n || dy<=0 || dy>m || a[dx][dy] <= a[x][y]) continue;
        dfs(dx, dy, val+1);
    }
};
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)for(int j=1;j<=m;j++) cin>>a[i][j];
    dfs(1, 1, 0);
    cout<<ans<<'\n';
}

200pts:
注意到，单纯用dfs的复杂度可能非常大。
采用记忆化搜索的方法，如果在搜索中求得了某个点出发的长度\(dp_{ij}\)，就记录在数组中，下次不用再花费时间求解了。
则，若\(_{i'j'}\to _{ij}\)，则有转移方程\(dp_{ij} = max(dp_{ij}, dp_{i'j'}+1)\)
时间复杂度是\(O(nm)\)

Code:

#include<bits/stdc++.h>
using namespace std;
int r,c,m[505][505],dp[505][505],ans;
int d[4][2]={
    1,0,
    -1,0,
    0,1,
    0,-1
};
int solve(int i,int j)
{
    if(i<=0||j<=0||i>r||j>c) return 0;
    if(dp[i][j]!=0) return dp[i][j];
    dp[i][j] = 1;
    for(int w=0;w<4;w++) 
        if(m[i][j]<m[i+d[w][0]][j+d[w][1]])
            dp[i][j]=max(dp[i][j],solve(i+d[w][0],j+d[w][1])+1);
    return dp[i][j];
}
int main()
{
    cin>>r>>c;
    for(int i=1;i<=r;i++) for(int j=1;j<=c;j++) cin>>m[i][j];
    cout<<solve(1,1)-1<<endl;
}