Leetcode Weekly Contest 86

Weekly Contest 86

A：840. 矩阵中的幻方

3 x 3 的幻方是一个填充有从 1 到 9 的不同数字的 3 x 3 矩阵，其中每行，每列以及两条对角线上的各数之和都相等。

给定一个由整数组成的 N × N 矩阵，其中有多少个 3 × 3 的 “幻方” 子矩阵？（每个子矩阵都是连续的）。

直接模拟即可，本来是签到题，由于粗心，浪费了时间。

 class Solution {
 public:
     int numMagicSquaresInside(vector<vector<int>>& grid) {
         vector<vector<int> >a = grid;
         int ans = ;
         for(int i = ; i +  < a.size(); i++)
         {
             for(int j = ; j +  < a[].size(); j++)
             {
                 set<int>s;
                 bool flag = ;
                 for(int ii = i; ii <= i + ; ii++)
                 {
                     for(int jj = j; jj <= j + ; jj++)
                     {
                         if(a[ii][jj] >=  || a[ii][jj] <= )
                         {
                             flag = ;
                         }
                         s.insert(a[ii][jj]);
                     }
                 }
                 if(flag && s.size() == )
                 {
                     int a1 = a[i][j] + a[i + ][j + ] + a[i + ][j + ];
                     int a2 = a[i][j + ] + a[i + ][j + ] + a[i + ][j];
                     //cout<<a1<<" "<<a2<<endl;
                     if(a1 == a2 && a1 == )
                     {
                         for(int ii = i; ii <= i + ; ii++)
                         {
                             int a3 = a[ii][j] + a[ii][j + ] + a[ii][j + ];
                             if(a3 != )flag = ;
                         }
                         for(int ii = j; ii <= j + ; ii++)
                         {
                             int a3 = a[i][ii] + a[i + ][ii] + a[i + ][ii];
                             if(a3 != )flag = ;
                         }
                         if(flag)ans++;
                     }
                 }
             }
         }
         return ans;
     }
 };

B：841. 钥匙和房间

有 N 个房间，开始时你位于 0 号房间。每个房间有不同的号码：0，1，2，...，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。

在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，...，N-1] 中的一个整数表示，其中 N = rooms.length。 钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。

最初，除 0 号房间外的其余所有房间都被锁住。

你可以自由地在房间之间来回走动。

如果能进入每个房间返回 true，否则返回 false。

直接用BFS即可，到达每一点，比赛的时候用并查集也过了，但是后来想这是有向边，并查集合并的是无向边，应该是数据水的原因

 class Solution {
 public:
     bool canVisitAllRooms(vector<vector<int> >& rooms) {
         queue<int>q;
         q.push();
         int vis[] = {};
         while(!q.empty())
         {
             int now = q.front();
             q.pop();
             for(int i = ; i < rooms[now].size(); i++)
             {
                 int next = rooms[now][i];
                 if(!vis[next])
                 {
                     vis[next] = ;
                     q.push(next);
                 }
             }
         }
         for(int i = ; i < rooms.size(); i++)
         {
             if(vis[i] == )return false;
         }
         return true;
     }
 };

C：842. 将数组拆分成斐波那契序列

给定一个数字字符串 S，比如 S = "123456579"，我们可以将它分成斐波那契式的序列 [123, 456, 579]。

形式上，斐波那契式序列是一个非负整数列表 F，且满足：

• 0 <= F[i] <= 2^31 - 1，（也就是说，每个整数都符合 32 位有符号整数类型）；
• F.length >= 3；
• 对于所有的0 <= i < F.length - 2，都有 F[i] + F[i+1] = F[i+2] 成立。

另外，请注意，将字符串拆分成小块时，每个块的数字一定不要以零开头，除非这个块是数字 0 本身。

返回从 S 拆分出来的所有斐波那契式的序列块，如果不能拆分则返回 []。

枚举第一项和第二项的位数即可，保证没有前导0，还需要保证以后的每一项在2的31次方以内

 class Solution {
 public:
     vector<int> splitIntoFibonacci(string S) {
         for(int i = ; i <= min(, (int)S.size()); i++)
         {
             for(int j = ; j <= min(, (int)S.size()); j++)
             {
                 if(i + j -  >= S.size())break;
                 string s1, s2;
                 for(int k = ; k < i; k++)s1 += S[k];
                 for(int k = i; k < i + j; k++)s2 += S[k];
                 if(s1[] == '' && i !=  || s2[] == '' && j != )continue;
                 vector<int>ans;
                 string tmp = s1 + s2;
                 stringstream ss(s1), ss1(s2);
                 long long a, b, c;
                 ss >> a;ss1 >> b;
                 ans.push_back(a);
                 ans.push_back(b);
                 while()
                 {
                     c = a + b;
                     if(c >= (1LL<<))
                     {
                         break;
                     }
                     ans.push_back(c);
                     stringstream ss;
                     ss << c;
                     string s3;
                     ss >> s3;
                     tmp += s3;
                     if(tmp.size() > S.size())break;
                     if(tmp == S)return ans;
                     a = b;
                     b = c;
                 }
             }
         }
         vector<int>ans;
         return ans;
     }
 };

D:843. 猜猜这个单词

这个问题是 LeetCode 平台新增的交互式问题 。

我们给出了一个由一些独特的单词组成的单词列表，每个单词都是 6 个字母长，并且这个列表中的一个单词将被选作秘密。

你可以调用 master.guess(word) 来猜单词。你所猜的单词应当是存在于原列表并且由 6 个小写字母组成的类型字符串。

此函数将会返回一个整型数字，表示你的猜测与秘密单词的准确匹配（值和位置同时匹配）的数目。此外，如果你的猜测不在给定的单词列表中，它将返回 -1。

对于每个测试用例，你有 10 次机会来猜出这个单词。当所有调用都结束时，如果您对 master.guess 的调用不超过 10 次，并且至少有一次猜到秘密，那么您将通过该测试用例。

除了下面示例给出的测试用例外，还会有 5 个额外的测试用例，每个单词列表中将会有 100 个单词。这些测试用例中的每个单词的字母都是从 'a' 到 'z' 中随机选取的，并且保证给定单词列表中的每个单词都是唯一的。

一开始以为是难题，后来发现就是水题一个，直接模拟即可，每次随机询问一个位置即可，得到答案为t，把字符串数组中与该位置有t个相同的字符串作为下一组字符串数组继续查询。

 /**
  * // This is the Master's API interface.
  * // You should not implement it, or speculate about its implementation
  * class Master {
  *   public:
  *     int guess(string word);
  * };
  */
 class Solution {
 public:
     int judge(string a, string b)
     {
         int tot = ;
         for(int i = ; i < a.size(); i++)
         {
             if(a[i] == b[i])tot++;
         }
         return tot;
     }
     void findSecretWord(vector<string>& wordlist, Master& master) {
         vector<string>now = wordlist, next;
         while()
         {
             next.clear();
             int s = rand()%now.size();
             int t = master.guess(now[s]);
             if(t == )break;
             for(int i = ; i < now.size(); i++)
             {
                 if(judge(now[i], now[s]) == t)
                     next.push_back(now[i]);
             }
             now = next;
         }
     }
 };